@xyo-network/xl1-protocol-sdk 1.11.0 → 1.12.1

package/dist/neutral/index.mjs

@@ -1,69 +1,97 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/block/hydrateBlock.ts
 import { filterAs } from "@xylabs/array";
 import { assertEx } from "@xylabs/assert";
-import {
-  asTransactionBoundWitnessWithStorageMeta,
-  isBlockBoundWitnessWithStorageMeta,
-  isTransactionBoundWitnessWithStorageMeta
-} from "@xyo-network/xl1-protocol";
+import { asTransactionBoundWitnessWithStorageMeta, isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 function allHashesPresent(hashes, payloads) {
   const payloadHashes = new Set(payloads.map((p) => p._hash));
   return hashes.every((hash) => payloadHashes.has(hash));
 }
-var tryHydrateBlock = async (archivist, hash, maxDepth = 1) => {
+__name(allHashesPresent, "allHashesPresent");
+var tryHydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1) => {
   assertEx(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
-  const bw = (await archivist.get([hash])).find(isBlockBoundWitnessWithStorageMeta);
+  const bw = (await archivist.get([
+    hash
+  ])).find(isBlockBoundWitnessWithStorageMeta);
   if (!bw) return void 0;
-  if (maxDepth === 0) return [bw, []];
+  if (maxDepth === 0) return [
+    bw,
+    []
+  ];
   const blkPayloads = await archivist.get(bw.payload_hashes);
-  if (maxDepth === 1) return [bw, blkPayloads];
+  if (maxDepth === 1) return [
+    bw,
+    blkPayloads
+  ];
   const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
   const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
   const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
-  const allPayloads = await archivist.get([...allPayloadsHashes]);
+  const allPayloadsHashes = new Set([
+    ...blkPayloads,
+    ...transactionsPayloads
+  ].flatMap((p) => p._hash));
+  const allPayloads = await archivist.get([
+    ...allPayloadsHashes
+  ]);
   const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  return [bw, allPayloadsFiltered];
-};
-var hydrateBlock = async (archivist, hash, maxDepth = 1, minDepth = maxDepth) => {
+  return [
+    bw,
+    allPayloadsFiltered
+  ];
+}, "tryHydrateBlock");
+var hydrateBlock = /* @__PURE__ */ __name(async (archivist, hash, maxDepth = 1, minDepth = maxDepth) => {
   assertEx(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
   assertEx(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
   assertEx(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
-  const bw = assertEx(
-    (await archivist.get([hash])).find(isBlockBoundWitnessWithStorageMeta),
-    () => `block ${hash} not found`
-  );
-  if (maxDepth === 0) return [bw, []];
+  const bw = assertEx((await archivist.get([
+    hash
+  ])).find(isBlockBoundWitnessWithStorageMeta), () => `block ${hash} not found`);
+  if (maxDepth === 0) return [
+    bw,
+    []
+  ];
   const blkPayloads = await archivist.get(bw.payload_hashes);
   if (minDepth === 1) assertEx(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
-  if (maxDepth === 1) return [bw, blkPayloads];
+  if (maxDepth === 1) return [
+    bw,
+    blkPayloads
+  ];
   const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
   const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
   const transactionsPayloads = await archivist.get(transactionsPayloadHashes);
   assertEx(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
-  const allPayloads = await archivist.get([...allPayloadsHashes]);
+  const allPayloadsHashes = new Set([
+    ...blkPayloads,
+    ...transactionsPayloads
+  ].flatMap((p) => p._hash));
+  const allPayloads = await archivist.get([
+    ...allPayloadsHashes
+  ]);
   const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  if (maxDepth === 2) assertEx(allHashesPresent(
-    [...allPayloadsHashes],
+  if (maxDepth === 2) assertEx(allHashesPresent([
+    ...allPayloadsHashes
+  ], allPayloadsFiltered), () => `Unable to find all payloads for transactions in block ${hash}`);
+  return [
+    bw,
     allPayloadsFiltered
-  ), () => `Unable to find all payloads for transactions in block ${hash}`);
-  return [bw, allPayloadsFiltered];
-};
-var flattenHydratedBlock = (hydratedBlock) => {
+  ];
+}, "hydrateBlock");
+var flattenHydratedBlock = /* @__PURE__ */ __name((hydratedBlock) => {
   const [blk, blkPayloads] = hydratedBlock;
-  return [...blkPayloads, blk];
-};
-var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk));
-var transactionsFromHydratedBlock = (block) => {
+  return [
+    ...blkPayloads,
+    blk
+  ];
+}, "flattenHydratedBlock");
+var flattenHydratedBlocks = /* @__PURE__ */ __name((hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk)), "flattenHydratedBlocks");
+var transactionsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
   return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta);
-};
-var blockPayloadsFromHydratedBlock = (block) => {
-  return block[0].payload_hashes.map((hash) => assertEx(
-    block[1].find((p) => p._hash === hash),
-    () => `missing payload ${hash}`
-  )).filter((x) => !isTransactionBoundWitnessWithStorageMeta(x));
-};
+}, "transactionsFromHydratedBlock");
+var blockPayloadsFromHydratedBlock = /* @__PURE__ */ __name((block) => {
+  return block[0].payload_hashes.map((hash) => assertEx(block[1].find((p) => p._hash === hash), () => `missing payload ${hash}`)).filter((x) => !isTransactionBoundWitnessWithStorageMeta(x));
+}, "blockPayloadsFromHydratedBlock");
 
 // src/block/primitives/balanceStepSummaryFromRange.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
@@ -72,12 +100,9 @@ import { isAnyPayload } from "@xyo-network/payload-model";
 import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol";
 
 // src/payload/netBalancesForPayloads.ts
-import {
-  hexToBigInt,
-  toAddress
-} from "@xylabs/hex";
+import { hexToBigInt, toAddress } from "@xylabs/hex";
 import { isTransfer } from "@xyo-network/xl1-protocol";
-var netBalancesForPayloads = (payloads) => {
+var netBalancesForPayloads = /* @__PURE__ */ __name((payloads) => {
   const balances = {};
   for (const payload of payloads) {
     if (isTransfer(payload)) {
@@ -89,21 +114,18 @@ var netBalancesForPayloads = (payloads) => {
     }
   }
   return balances;
-};
+}, "netBalancesForPayloads");
 
 // src/SignedBigInt.ts
-import {
-  hexToBigInt as hexToBigInt2,
-  toHex
-} from "@xylabs/hex";
+import { hexToBigInt as hexToBigInt2, toHex } from "@xylabs/hex";
 import { isObject } from "@xylabs/object";
-var isNegativeBigInt = (value) => {
+var isNegativeBigInt = /* @__PURE__ */ __name((value) => {
   return isObject(value) && "negative" in value && typeof value.negative === "string";
-};
-var isPositiveBigInt = (value) => {
+}, "isNegativeBigInt");
+var isPositiveBigInt = /* @__PURE__ */ __name((value) => {
   return isObject(value) && "positive" in value && typeof value.positive === "string";
-};
-var parseSignedBigInt = (value) => {
+}, "isPositiveBigInt");
+var parseSignedBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
     return -hexToBigInt2(value.negative);
   } else if (isPositiveBigInt(value)) {
@@ -111,22 +133,32 @@ var parseSignedBigInt = (value) => {
   } else {
     throw new Error("Invalid balance type");
   }
-};
-var toSignedBigInt = (value) => {
-  return value < 0n ? { negative: toHex(-value) } : { positive: toHex(value) };
-};
-var toPositiveBigInt = (value) => {
+}, "parseSignedBigInt");
+var toSignedBigInt = /* @__PURE__ */ __name((value) => {
+  return value < 0n ? {
+    negative: toHex(-value)
+  } : {
+    positive: toHex(value)
+  };
+}, "toSignedBigInt");
+var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
   if (isNegativeBigInt(value)) {
-    return { positive: toHex(0n) };
+    return {
+      positive: toHex(0n)
+    };
   }
   if (isPositiveBigInt(value)) {
-    return { positive: value.positive };
+    return {
+      positive: value.positive
+    };
   }
   if (typeof value === "bigint") {
-    return { positive: toHex(value) };
+    return {
+      positive: toHex(value)
+    };
   }
   throw new Error("Invalid value for positive big int");
-};
+}, "toPositiveBigInt");
 
 // src/block/primitives/frames/calculateFramesFromRange.ts
 import { stepSize } from "@xyo-network/xl1-protocol";
@@ -137,23 +169,38 @@ function calculateFramesFromRange(range, step) {
   const remaining = [];
   if (start !== range[0]) {
     start += size;
-    remaining.push([range[0], Math.min(start - 1, range[1])]);
+    remaining.push([
+      range[0],
+      Math.min(start - 1, range[1])
+    ]);
   }
   for (let i = start; i <= range[1]; i += size) {
     if (i + size - 1 <= range[1]) {
-      fitted.push([i, Math.min(i + size - 1, range[1])]);
+      fitted.push([
+        i,
+        Math.min(i + size - 1, range[1])
+      ]);
     } else {
-      remaining.push([i, range[1]]);
+      remaining.push([
+        i,
+        range[1]
+      ]);
     }
   }
-  return [fitted, remaining];
+  return [
+    fitted,
+    remaining
+  ];
 }
+__name(calculateFramesFromRange, "calculateFramesFromRange");
 
 // src/block/primitives/frames/deepCalculateFramesFromRange.ts
 import { StepSizes } from "@xyo-network/xl1-protocol";
 function deepCalculateFramesFromRange(range, startingStep = StepSizes.length - 1) {
   const fitted = [];
-  let remaining = [range];
+  let remaining = [
+    range
+  ];
   for (let step = startingStep; step >= 0; step--) {
     const newRemaining = [];
     for (const range2 of remaining) {
@@ -165,19 +212,27 @@ function deepCalculateFramesFromRange(range, startingStep = StepSizes.length - 1
   }
   for (const range2 of remaining) {
     for (let i = range2[0]; i <= range2[1]; i++) {
-      fitted.push([i, i]);
+      fitted.push([
+        i,
+        i
+      ]);
     }
   }
   return fitted.toSorted((a, b) => a[0] - b[0]);
 }
+__name(deepCalculateFramesFromRange, "deepCalculateFramesFromRange");
 
 // src/block/primitives/hashFromBlockNumber.ts
 import { asHash } from "@xylabs/hex";
 import { toSafeJsonString } from "@xylabs/object";
 import { asBlockBoundWitnessWithStorageMeta, StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol";
 async function hashFromBlockNumber(context, blockNumber) {
-  const result = await context.chainArchivist.get([context.head]);
-  let currentBlock = asBlockBoundWitnessWithStorageMeta(result.at(0), () => `Head block not found for hash: ${context.head}`, { required: true });
+  const result = await context.chainArchivist.get([
+    context.head
+  ]);
+  let currentBlock = asBlockBoundWitnessWithStorageMeta(result.at(0), () => `Head block not found for hash: ${context.head}`, {
+    required: true
+  });
   while (currentBlock.block > blockNumber) {
     let jumpHash = currentBlock.previous;
     let jumpBlockNumber = currentBlock.block - 1;
@@ -191,7 +246,9 @@ async function hashFromBlockNumber(context, blockNumber) {
     const [newBlock] = await context.chainArchivist.get([
       asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
     ]);
-    currentBlock = asBlockBoundWitnessWithStorageMeta(newBlock, () => `Block not found for hash: ${jumpHash}`, { required: true });
+    currentBlock = asBlockBoundWitnessWithStorageMeta(newBlock, () => `Block not found for hash: ${jumpHash}`, {
+      required: true
+    });
     if (currentBlock.block === blockNumber) {
       break;
     }
@@ -201,6 +258,7 @@ async function hashFromBlockNumber(context, blockNumber) {
   }
   return currentBlock._hash;
 }
+__name(hashFromBlockNumber, "hashFromBlockNumber");
 
 // src/block/primitives/payloads.ts
 import { AsObjectFactory } from "@xylabs/object";
@@ -209,9 +267,9 @@ var StepSummarySchema = "network.xyo.step.summary";
 var BalancesStepSummarySchema = "network.xyo.step.summary.balances";
 var isBalancesStepSummary = isPayloadOfSchemaType(BalancesStepSummarySchema);
 var asBalancesStepSummary = AsObjectFactory.create(isBalancesStepSummary);
-var isBalancesStepSummaryWithStorageMeta = (value) => {
+var isBalancesStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
   return isBalancesStepSummary(value) && isStorageMeta(value);
-};
+}, "isBalancesStepSummaryWithStorageMeta");
 var asBalancesStepSummaryWithStorageMeta = AsObjectFactory.create(isBalancesStepSummaryWithStorageMeta);
 
 // src/block/primitives/balanceStepSummaryFromRange.ts
@@ -235,15 +293,14 @@ async function balanceStepSummaryFromRange(context, range) {
   } else {
     const step = StepSizes3.indexOf(frameSize);
     assertEx2(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes3.join(", ")}`);
-    const [summaryResult] = await context.summaryRepository.get([frameHeadHash]);
+    const [summaryResult] = await context.summaryRepository.get([
+      frameHeadHash
+    ]);
     if (isAnyPayload(summaryResult)) {
       result = summaryResult;
     } else {
       const subRanges = deepCalculateFramesFromRange(range, step - 1);
-      const promises = subRanges.map((subRange) => balanceStepSummaryFromRange(
-        context,
-        subRange
-      ));
+      const promises = subRanges.map((subRange) => balanceStepSummaryFromRange(context, subRange));
       const subResults = await Promise.all(promises);
       const bigIntBalances = {};
       for (const subResult of subResults) {
@@ -261,22 +318,32 @@ async function balanceStepSummaryFromRange(context, range) {
         stepSize: frameSize,
         balances
       };
-      await context.summaryRepository.insert([result]);
+      await context.summaryRepository.insert([
+        result
+      ]);
     }
   }
   const finalResult = await PayloadBuilder.addStorageMeta(result);
   return finalResult;
 }
+__name(balanceStepSummaryFromRange, "balanceStepSummaryFromRange");
 
 // src/block/primitives/balanceSummary.ts
 import { asAddress } from "@xylabs/hex";
 import { isDefined } from "@xylabs/typeof";
 import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
 async function balanceSummary(context) {
-  const headResult = await context.chainArchivist.get([context.head]);
-  const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult.at(0), () => `Head block not found for hash: ${context.head}`, { required: true });
+  const headResult = await context.chainArchivist.get([
+    context.head
+  ]);
+  const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult.at(0), () => `Head block not found for hash: ${context.head}`, {
+    required: true
+  });
   const rangeStart = isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0;
-  const ranges = deepCalculateFramesFromRange([rangeStart, headBoundWitness.block]);
+  const ranges = deepCalculateFramesFromRange([
+    rangeStart,
+    headBoundWitness.block
+  ]);
   const summaries = await Promise.all(ranges.map((range) => balanceStepSummaryFromRange(context, range)));
   const balances = {};
   for (let summary of summaries) {
@@ -287,134 +354,287 @@ async function balanceSummary(context) {
   }
   return balances;
 }
+__name(balanceSummary, "balanceSummary");
 
 // src/config/Config.ts
-import { LogLevel } from "@xylabs/logger";
-import z10 from "zod";
+import z11 from "zod";
 
 // src/config/Api.ts
-import z2 from "zod";
+import z2, { globalRegistry } from "zod";
 
 // src/validation/lib/isLocalhost.ts
-var isLocalhost = (hostname) => {
+var isLocalhost = /* @__PURE__ */ __name((hostname) => {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
-};
+}, "isLocalhost");
 
 // src/validation/lib/getUrl.ts
-var getUrl = (host, port) => {
+var getUrl = /* @__PURE__ */ __name((host, port) => {
   const scheme = isLocalhost(host) ? "http" : "https";
   return `${scheme}://${host}:${port}`;
-};
+}, "getUrl");
 
 // src/validation/schema/Address.ts
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
 import { z } from "zod";
-var MnemonicStringSchema = z.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
-  (s) => [12, 15, 18, 21, 24].includes(s.split(" ").length),
-  { message: "Mnemonic must contain 12, 15, 18, 21, or 24 words." }
-).describe("BIP-39 mnemonic string");
+var MnemonicStringZod = z.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine((s) => [
+  12,
+  15,
+  18,
+  21,
+  24
+].includes(s.split(" ").length), {
+  message: "Mnemonic must contain 12, 15, 18, 21, or 24 words."
+}).describe("BIP-39 mnemonic string");
 
 // src/config/Api.ts
-var ApiConfigSchema = z2.object({
-  mnemonic: MnemonicStringSchema.optional().describe("Mnemonic for the API wallet"),
-  host: z2.string().default("localhost").describe("Host for the API"),
-  port: z2.coerce.number().default(8080).describe("Port for the API")
+var ApiConfigZod = z2.object({
+  host: z2.string().default("localhost").register(globalRegistry, {
+    default: "localhost",
+    description: "Host for the API",
+    title: "api.host",
+    type: "string"
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
+    description: "Mnemonic for the API wallet",
+    title: "api.mnemonic",
+    type: "string"
+  }),
+  port: z2.coerce.number().default(8080).register(globalRegistry, {
+    default: 8080,
+    description: "Port for the API",
+    title: "api.port",
+    type: "number"
+  })
 });
 
 // src/config/App.ts
-import z3 from "zod";
-var AppConfigSchema = z3.object({ port: z3.coerce.number().default(3e3).describe("Port for the application") });
+import z3, { globalRegistry as globalRegistry2 } from "zod";
+var AppConfigZod = z3.object({
+  port: z3.coerce.number().default(3e3).register(globalRegistry2, {
+    default: 3e3,
+    description: "Port for the application",
+    title: "app.port",
+    type: "number"
+  })
+});
 
 // src/config/Chain.ts
-import z4 from "zod";
-var ChainConfigSchema = z4.object({
-  id: z4.string().optional().describe("The unique identifier for the chain. Should be the staking contract address for contract-backed chains.")
+import z4, { globalRegistry as globalRegistry3 } from "zod";
+var ChainConfigZod = z4.object({
+  id: z4.string().optional().register(globalRegistry3, {
+    description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
+    title: "chain.id",
+    type: "string"
+  })
 });
 
 // src/config/Evm.ts
-import z5 from "zod";
-var EvmJsonRpcConfigSchema = z5.object({
-  //
-  url: z5.string().optional().describe("JSON-RPC URL")
+import z5, { globalRegistry as globalRegistry4 } from "zod";
+var EvmInfuraConfigZod = z5.object({
+  projectId: z5.string().optional().register(globalRegistry4, {
+    description: "Infura project ID",
+    title: "evm.infura.projectId",
+    type: "string"
+  }),
+  projectSecret: z5.string().optional().register(globalRegistry4, {
+    description: "Infura project secret",
+    title: "evm.infura.projectSecret",
+    type: "string"
+  })
 });
-var EvmInfuraConfigSchema = z5.object({
-  projectId: z5.string().optional().describe("Infura project ID"),
-  projectSecret: z5.string().optional().describe("Infura project secret")
+var EvmJsonRpcConfigZod = z5.object({
+  url: z5.url().optional().register(globalRegistry4, {
+    description: "JSON-RPC URL",
+    title: "evm.jsonRpc.url",
+    type: "string"
+  })
 });
-var EvmConfigSchema = z5.object({
-  chainId: z5.string().optional().describe("EVM chain ID"),
-  infura: EvmInfuraConfigSchema.optional().describe("Infura Provider configuration"),
-  jsonRpc: EvmJsonRpcConfigSchema.optional().describe("JSON-RPC Provider configuration")
+var EvmConfigZod = z5.object({
+  chainId: z5.string().optional().register(globalRegistry4, {
+    description: "EVM chain ID",
+    title: "evm.chainId",
+    type: "string"
+  }),
+  infura: EvmInfuraConfigZod.optional().describe("Infura Provider configuration"),
+  jsonRpc: EvmJsonRpcConfigZod.optional().describe("JSON-RPC Provider configuration")
+});
+
+// src/config/Log.ts
+import { LogLevel } from "@xylabs/logger";
+import z6, { globalRegistry as globalRegistry5 } from "zod";
+var LogLevels = Object.keys(LogLevel);
+var LogConfigZod = z6.object({
+  logLevel: z6.enum(LogLevels).default("info").register(globalRegistry5, {
+    choices: LogLevels,
+    default: "info",
+    description: "Desired process verbosity",
+    title: "logLevel",
+    type: "string"
+  }),
+  silent: z6.boolean().default(false).register(globalRegistry5, {
+    default: false,
+    description: "Whether to run in silent mode",
+    title: "silent",
+    type: "boolean"
+  })
 });
 
 // src/config/Producer.ts
-import z6 from "zod";
-var ProducerConfigSchema = z6.object({
+import z7, { globalRegistry as globalRegistry6 } from "zod";
+var ProducerConfigZod = z7.object({
+  disableIntentRedeclaration: z7.boolean().optional().register(globalRegistry6, {
+    description: "Should the producer skip redeclaring their intent to continue producing blocks",
+    title: "producer.disableIntentRedeclaration",
+    type: "boolean"
+  }),
   // TODO: Port schema
-  healthCheckPort: z6.coerce.number().optional().describe("Port for the Producer health checks"),
+  healthCheckPort: z7.coerce.number().optional().register(globalRegistry6, {
+    description: "Port for the Producer health checks",
+    title: "producer.healthCheckPort",
+    type: "number"
+  }),
   // TODO: BigInt schema
-  minStake: z6.coerce.number().default(1).describe("Minimum stake required to be a Producer"),
-  mnemonic: MnemonicStringSchema.optional().describe("Mnemonic for the Producer wallet"),
+  minStake: z7.coerce.number().default(1).register(globalRegistry6, {
+    description: "Minimum stake required to be a Producer",
+    title: "producer.minStake",
+    type: "number"
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry6, {
+    description: "Mnemonic for the Producer wallet",
+    title: "producer.mnemonic",
+    type: "string"
+  }),
   // TODO: Port schema
-  port: z6.coerce.number().default(8081).describe("Port for the Producer"),
-  disableIntentRedeclaration: z6.boolean().optional().describe("Should the producer skip redeclaring their intent to continue producing blocks"),
+  port: z7.coerce.number().default(8081).register(globalRegistry6, {
+    default: 8081,
+    description: "Port for the Producer",
+    title: "producer.port",
+    type: "number"
+  }),
   // TODO: Address schema
-  rewardAddress: z6.string().optional().describe("Address to receive block rewards")
+  rewardAddress: z7.string().optional().register(globalRegistry6, {
+    description: "Address to receive block rewards",
+    title: "producer.rewardAddress",
+    type: "string"
+  })
 });
 
 // src/config/storage/driver/Mongo.ts
 import { isDefined as isDefined2, isUndefined } from "@xylabs/typeof";
-import z7 from "zod";
-var hasMongoConfig = (config) => {
+import z8, { globalRegistry as globalRegistry7 } from "zod";
+var hasMongoConfig = /* @__PURE__ */ __name((config) => {
   if (isUndefined(config)) return false;
   return isDefined2(config.connectionString) && isDefined2(config.database) && isDefined2(config.domain) && isDefined2(config.password) && isDefined2(config.username);
-};
-var MongoConfigSchema = z7.object({
+}, "hasMongoConfig");
+var MongoConfigZod = z8.object({
   // TODO: Create from other arguments
-  connectionString: z7.string().min(1).optional().describe("MongoDB connection string"),
-  database: z7.string().min(1).optional().describe("MongoDB database name"),
-  domain: z7.string().min(1).optional().describe("MongoDB domain"),
-  password: z7.string().min(1).optional().describe("MongoDB password"),
-  username: z7.string().min(1).optional().describe("MongoDB username")
+  connectionString: z8.string().min(1).optional().register(globalRegistry7, {
+    description: "MongoDB connection string",
+    title: "storage.mongo.connectionString",
+    type: "string"
+  }),
+  database: z8.string().min(1).optional().register(globalRegistry7, {
+    description: "MongoDB database name",
+    title: "storage.mongo.database",
+    type: "string"
+  }),
+  domain: z8.string().min(1).optional().register(globalRegistry7, {
+    description: "MongoDB domain",
+    title: "storage.mongo.domain",
+    type: "string"
+  }),
+  password: z8.string().min(1).optional().register(globalRegistry7, {
+    description: "MongoDB password",
+    title: "storage.mongo.password",
+    type: "string"
+  }),
+  username: z8.string().min(1).optional().register(globalRegistry7, {
+    description: "MongoDB username",
+    title: "storage.mongo.username",
+    type: "string"
+  })
 });
 
 // src/config/storage/Storage.ts
-import z8 from "zod";
-var StorageConfigSchema = z8.object({
-  mongo: MongoConfigSchema.optional().describe("Configuration for the MongoDBstorage driver"),
-  root: z8.string().optional().describe("Root directory for local storage")
+import z9, { globalRegistry as globalRegistry8 } from "zod";
+var StorageConfigZod = z9.object({
+  mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
+  root: z9.string().optional().register(globalRegistry8, {
+    description: "Root directory for local storage",
+    title: "storage.root",
+    type: "string"
+  })
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import z9 from "zod";
-var OpenTelemetryConfigSchema = z9.object({
+import z10, { globalRegistry as globalRegistry9 } from "zod";
+var OpenTelemetryConfigZod = z10.object({
   // OpenTelemetry options
-  otlpEndpoint: z9.string().optional().describe("OTLP endpoint for exporting telemetry data")
+  otlpEndpoint: z10.url().optional().register(globalRegistry9, {
+    description: "OTLP endpoint for exporting telemetry data",
+    title: "telemetry.otel.otlpEndpoint",
+    type: "string"
+  })
 });
-var TelemetryConfigSchema = z9.object({
+var TelemetryConfigZod = z10.object({
   // OpenTelemetry configuration
-  otel: OpenTelemetryConfigSchema.optional().describe("OpenTelemetry configuration")
+  otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
 
 // src/config/Config.ts
-var LogLevels = Object.keys(LogLevel);
-var Xl1CommonConfigSchema = z10.object({
-  silent: z10.boolean().default(false).describe("Whether to run in silent mode"),
-  logLevel: z10.enum(LogLevels).default("info").describe("Desired process verbosity")
+var Xl1CommonConfigSchema = z11.object({
+  ...LogConfigZod.shape
 }).describe("XL1 common configuration options");
-var ConfigSchema = z10.object({
+var ConfigZod = z11.object({
   ...Xl1CommonConfigSchema.shape,
-  api: ApiConfigSchema.default(ApiConfigSchema.parse({})).describe("Configuration for the API node"),
-  app: AppConfigSchema.default(AppConfigSchema.parse({})).describe("Configuration for the application"),
-  chain: ChainConfigSchema.default(ChainConfigSchema.parse({})).describe("Configuration for the chain"),
-  evm: EvmConfigSchema.default(EvmConfigSchema.parse({})).describe("Configuration for EVM-backed services"),
-  producer: ProducerConfigSchema.default(ProducerConfigSchema.parse({})).describe("Configuration for the producer"),
-  storage: StorageConfigSchema.default(StorageConfigSchema.parse({})).describe("Configuration for the storage"),
-  telemetry: TelemetryConfigSchema.default(TelemetryConfigSchema.parse({})).describe("Configuration for telemetry")
+  api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
+  app: AppConfigZod.default(AppConfigZod.parse({})).describe("Configuration for the application"),
+  chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
+  evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
+  producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe("Configuration for the producer"),
+  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
+  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry")
 });
-var getDefaultConfig = () => ConfigSchema.parse({});
+var getDefaultConfig = /* @__PURE__ */ __name(() => ConfigZod.parse({}), "getDefaultConfig");
+
+// src/config/UsageMeta.ts
+import z12 from "zod";
+var DescriptionSchema = z12.string();
+var TitleSchema = z12.string();
+var JSONSchemaMetaSchema = z12.object({
+  id: z12.string().optional(),
+  title: TitleSchema.optional(),
+  description: DescriptionSchema.optional(),
+  deprecated: z12.boolean().optional()
+}).catchall(z12.unknown());
+var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
+var ChoicesSchema = z12.array(z12.union([
+  z12.string(),
+  z12.number(),
+  z12.literal(true),
+  z12.undefined()
+])).readonly();
+var UsageMetaSchema = GlobalMetaSchema.extend({
+  choices: ChoicesSchema.optional(),
+  default: z12.unknown().optional(),
+  description: DescriptionSchema,
+  group: z12.string().optional(),
+  hidden: z12.boolean().optional(),
+  title: TitleSchema,
+  type: z12.union([
+    z12.literal("array"),
+    z12.literal("count"),
+    z12.literal("boolean"),
+    z12.literal("number"),
+    z12.literal("string")
+  ])
+});
+function isUsageMeta(v) {
+  return UsageMetaSchema.safeParse(v).success;
+}
+__name(isUsageMeta, "isUsageMeta");
 
 // src/transaction/buildTransaction.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
@@ -449,9 +669,20 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   if (script.length > 0) {
     fields.script = script;
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]).build();
-  return [await PayloadBuilder2.addStorageMeta(tx), await PayloadBuilder2.addStorageMeta(txPayloads)];
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).signers(Array.isArray(signer) ? signer : [
+    signer
+  ]).build();
+  return [
+    await PayloadBuilder2.addStorageMeta(tx),
+    await PayloadBuilder2.addStorageMeta(txPayloads)
+  ];
 }
+__name(buildTransaction, "buildTransaction");
 
 // src/transaction/buildUnsignedTransaction.ts
 import { toHex as toHex3 } from "@xylabs/hex";
@@ -482,9 +713,18 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
   if (script.length > 0) {
     fields.script = script;
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).build();
-  return [await PayloadBuilder3.addStorageMeta(tx), await PayloadBuilder3.addStorageMeta(txPayloads)];
+  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).build();
+  return [
+    await PayloadBuilder3.addStorageMeta(tx),
+    await PayloadBuilder3.addStorageMeta(txPayloads)
+  ];
 }
+__name(buildUnsignedTransaction, "buildUnsignedTransaction");
 
 // src/transaction/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
@@ -492,7 +732,7 @@ import { isDefined as isDefined3 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
-var confirmSubmittedTransaction = async (viewer, transaction, options) => {
+var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transaction, options) => {
   const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options || {};
   const txBWHash = await PayloadBuilder4.hash(transaction);
   options?.logger?.log("\u{1F680} confirming transaction:", txBWHash, "\n");
@@ -513,32 +753,27 @@ var confirmSubmittedTransaction = async (viewer, transaction, options) => {
       }
     }
   }
-};
+}, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
 import { assertEx as assertEx4 } from "@xylabs/assert";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
-import { isAllowedBlockPayload, isTransactionBoundWitnessWithStorageMeta as isTransactionBoundWitnessWithStorageMeta2 } from "@xyo-network/xl1-protocol";
-var tryHydrateTransaction = async (archivist, hash) => {
-  return await tryHydrateTypedBoundWitness(
-    archivist,
-    hash,
-    isTransactionBoundWitnessWithStorageMeta2
-  );
-};
-var hydrateTransaction = async (archivist, hash) => {
-  return await hydrateTypedBoundWitness(
-    archivist,
-    hash,
-    isTransactionBoundWitnessWithStorageMeta2
-  );
-};
-var flattenHydratedTransaction = (hydratedTransaction) => {
+import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+var tryHydrateTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
+  return await tryHydrateTypedBoundWitness(archivist, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+}, "tryHydrateTransaction");
+var hydrateTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
+  return await hydrateTypedBoundWitness(archivist, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+}, "hydrateTransaction");
+var flattenHydratedTransaction = /* @__PURE__ */ __name((hydratedTransaction) => {
   const [tx, txPayloads] = hydratedTransaction;
-  return [...txPayloads, tx];
-};
-var flattenHydratedTransactions = (hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx));
-var tryHydrateElevatedTransaction = async (archivist, hash) => {
+  return [
+    ...txPayloads,
+    tx
+  ];
+}, "flattenHydratedTransaction");
+var flattenHydratedTransactions = /* @__PURE__ */ __name((hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx)), "flattenHydratedTransactions");
+var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
   const hydratedTransaction = await tryHydrateTransaction(archivist, hash);
   if (!hydratedTransaction) {
     return void 0;
@@ -556,13 +791,16 @@ var tryHydrateElevatedTransaction = async (archivist, hash) => {
     }
   }
   if (opCodes.length === elevatedPayloads.length) {
-    return [transaction, elevatedPayloads];
+    return [
+      transaction,
+      elevatedPayloads
+    ];
   }
   return void 0;
-};
-var hydrateElevatedTransaction = async (archivist, hash) => {
+}, "tryHydrateElevatedTransaction");
+var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (archivist, hash) => {
   return assertEx4(await tryHydrateElevatedTransaction(archivist, hash), () => "Hydration failed");
-};
+}, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
@@ -572,6 +810,7 @@ function transactionBlockByteCount([transaction, payloads]) {
   const cleanPayloads = PayloadBuilder5.omitStorageMeta(payloads);
   return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
+__name(transactionBlockByteCount, "transactionBlockByteCount");
 
 // src/transaction/primitives/transactionElevatedPayloads.ts
 import { asHash as asHash2 } from "@xylabs/hex";
@@ -582,65 +821,77 @@ function crackOperation(operation) {
   if (parts.length < 2) {
     throw new Error(`Invalid operation format: ${operation}`);
   }
-  return [parts[0], parts.slice(1)];
+  return [
+    parts[0],
+    parts.slice(1)
+  ];
 }
+__name(crackOperation, "crackOperation");
 function crackOperations(operations) {
   return operations.map((op) => crackOperation(op));
 }
+__name(crackOperations, "crackOperations");
 
 // src/transaction/primitives/transactionElevatedPayloads.ts
 function transactionElevatedPayloadHashes(transaction) {
   const elevateOperations = crackOperations(transaction.script ?? []).filter((op) => op[0] === "elevate");
   return elevateOperations.map((op) => asHash2(op[1][0], true));
 }
+__name(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
 function transactionElevatedPayloads([transaction, payloads]) {
   const hashes = transactionElevatedPayloadHashes(transaction);
   const elevatedPayloads = payloads.filter((payload) => hashes.includes(payload._hash));
   return elevatedPayloads;
 }
+__name(transactionElevatedPayloads, "transactionElevatedPayloads");
 
 // src/transaction/primitives/transactionRequiredGas.ts
 import { AttoXL1, TransactionGasCosts } from "@xyo-network/xl1-protocol";
 function transactionBytesRequiredGas([transaction, payloads]) {
-  const transactionBlockBytes = transactionBlockByteCount([transaction, payloads]);
+  const transactionBlockBytes = transactionBlockByteCount([
+    transaction,
+    payloads
+  ]);
   return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
 }
+__name(transactionBytesRequiredGas, "transactionBytesRequiredGas");
 function transactionRequiredGas(hydratedTransaction) {
   const elevatedPayloads = transactionElevatedPayloads(hydratedTransaction);
   const hashes = elevatedPayloads.length + 1;
   const signatures = hydratedTransaction[0].addresses.length;
   return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads.length));
 }
+__name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
 import { assertEx as assertEx5 } from "@xylabs/assert";
 import { asHash as asHash3 } from "@xylabs/hex";
 import { isAllowedBlockPayloadWithHashStorageMeta } from "@xyo-network/xl1-protocol";
-var tryExtractElevatedHashesFromScript = (strings) => {
+var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   return filterAs2(hashes, (h) => asHash3(h));
-};
-var extractElevatedHashesFromScript = (strings) => {
+}, "tryExtractElevatedHashesFromScript");
+var extractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   const filtered = filterAs2(hashes, (h) => asHash3(h));
   assertEx5(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
-};
-var tryExtractElevatedHashes = (tx) => {
+}, "extractElevatedHashesFromScript");
+var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const [bw, payloads] = tx;
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashStorageMeta);
-};
-var extractElevatedHashes = (tx) => {
+}, "tryExtractElevatedHashes");
+var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const [bw, payloads] = tx;
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashStorageMeta);
   assertEx5(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
-};
+}, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
 import { toArrayBuffer } from "@xylabs/arraybuffer";
@@ -650,42 +901,63 @@ import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder"
 async function signTransaction(tx, account) {
   assertEx6(tx.from === account.address, () => "Signer address does not match transaction from address");
   const signedTx = structuredClone(tx);
-  signedTx.addresses = [account.address];
-  signedTx.previous_hashes = [account.previousHash ?? null];
+  signedTx.addresses = [
+    account.address
+  ];
+  signedTx.previous_hashes = [
+    account.previousHash ?? null
+  ];
   const hash = await PayloadBuilder6.hash(signedTx);
   const hashBytes = toArrayBuffer(hash);
   const [signature] = await account.sign(hashBytes);
-  signedTx.$signatures = [hexFromArrayBuffer(signature)];
+  signedTx.$signatures = [
+    hexFromArrayBuffer(signature)
+  ];
   return signedTx;
 }
+__name(signTransaction, "signTransaction");
 
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
 import { HDWallet } from "@xyo-network/wallet";
 
 // src/wallet/paths.ts
 var WALLET_COMPLIANCE = "44'";
-var COIN_TYPES = { Ethereum: "60'" };
-var ACCOUNT_TYPE = { GANACHE: "0'", XYO: "0'" };
-var CHANGE_ADDRESS = { META_MASK: "0", XYO: "0" };
-var ADDRESS_INDEX = { META_MASK: "0", XYO: "0" };
+var COIN_TYPES = {
+  Ethereum: "60'"
+};
+var ACCOUNT_TYPE = {
+  GANACHE: "0'",
+  XYO: "0'"
+};
+var CHANGE_ADDRESS = {
+  META_MASK: "0",
+  XYO: "0"
+};
+var ADDRESS_INDEX = {
+  META_MASK: "0",
+  XYO: "0"
+};
 var DEFAULT_WALLET_PATH = `m/${WALLET_COMPLIANCE}/${COIN_TYPES.Ethereum}/${ACCOUNT_TYPE.XYO}/${CHANGE_ADDRESS.XYO}`;
 
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
-var generateXyoBaseWalletFromPhrase = (walletPhrase) => {
+var generateXyoBaseWalletFromPhrase = /* @__PURE__ */ __name((walletPhrase) => {
   const wallet = HDWallet.fromPhrase(walletPhrase, DEFAULT_WALLET_PATH);
   return wallet;
-};
+}, "generateXyoBaseWalletFromPhrase");
 export {
   ACCOUNT_TYPE,
   ADDRESS_INDEX,
   BalancesStepSummarySchema,
   CHANGE_ADDRESS,
   COIN_TYPES,
-  ConfigSchema,
+  ConfigZod,
   DEFAULT_WALLET_PATH,
-  MnemonicStringSchema,
+  GlobalMetaSchema,
+  JSONSchemaMetaSchema,
+  MnemonicStringZod,
   StepSummarySchema,
   TODO,
+  UsageMetaSchema,
   WALLET_COMPLIANCE,
   Xl1CommonConfigSchema,
   allHashesPresent,
@@ -720,6 +992,7 @@ export {
   isLocalhost,
   isNegativeBigInt,
   isPositiveBigInt,
+  isUsageMeta,
   netBalancesForPayloads,
   parseSignedBigInt,
   signTransaction,