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

package/dist/neutral/config/storage/driver/Mongo.d.ts

@@ -7,24 +7,12 @@ import z from 'zod';
  * establishing a connection
  */
 export declare const hasMongoConfig: (config?: MongoConfig) => config is Required<MongoConfig>;
-export declare const MongoConfigSchema: z.ZodObject<{
+export declare const MongoConfigZod: z.ZodObject<{
     connectionString: z.ZodOptional<z.ZodString>;
     database: z.ZodOptional<z.ZodString>;
     domain: z.ZodOptional<z.ZodString>;
     password: z.ZodOptional<z.ZodString>;
     username: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    connectionString?: string | undefined;
-    database?: string | undefined;
-    domain?: string | undefined;
-    password?: string | undefined;
-    username?: string | undefined;
-}, {
-    connectionString?: string | undefined;
-    database?: string | undefined;
-    domain?: string | undefined;
-    password?: string | undefined;
-    username?: string | undefined;
-}>;
-export type MongoConfig = z.infer<typeof MongoConfigSchema>;
+}, z.z.core.$strip>;
+export type MongoConfig = z.infer<typeof MongoConfigZod>;
 //# sourceMappingURL=Mongo.d.ts.map

package/dist/neutral/config/storage/driver/Mongo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mongo.d.ts","sourceRoot":"","sources":["../../../../../src/config/storage/driver/Mongo.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,WAAW,KAAG,MAAM,IAAI,QAAQ,CAAC,WAAW,CASnF,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAO5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"Mongo.d.ts","sourceRoot":"","sources":["../../../../../src/config/storage/driver/Mongo.ts"],"names":[],"mappings":"AACA,OAAO,CAAqB,MAAM,KAAK,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,WAAW,KAAG,MAAM,IAAI,QAAQ,CAAC,WAAW,CASnF,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;mBA2BzB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/dist/neutral/index.mjs

@@ -289,11 +289,10 @@ async function balanceSummary(context) {
 }
 
 // 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) => {
@@ -311,110 +310,250 @@ var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
 import { z } from "zod";
-var MnemonicStringSchema = z.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+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";
+import z8, { globalRegistry as globalRegistry7 } from "zod";
 var hasMongoConfig = (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({
+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")
-}).describe("XL1 common configuration options");
-var ConfigSchema = z10.object({
+var Xl1CommonConfigSchema = z11.object({ ...LogConfigZod.shape }).describe("XL1 common configuration options");
+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 = () => ConfigZod.parse({});
+
+// 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;
+}
 
 // src/transaction/buildTransaction.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
@@ -518,19 +657,19 @@ var confirmSubmittedTransaction = async (viewer, transaction, options) => {
 // 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";
+import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = async (archivist, hash) => {
   return await tryHydrateTypedBoundWitness(
     archivist,
     hash,
-    isTransactionBoundWitnessWithStorageMeta2
+    isSignedTransactionBoundWitnessWithStorageMeta
   );
 };
 var hydrateTransaction = async (archivist, hash) => {
   return await hydrateTypedBoundWitness(
     archivist,
     hash,
-    isTransactionBoundWitnessWithStorageMeta2
+    isSignedTransactionBoundWitnessWithStorageMeta
   );
 };
 var flattenHydratedTransaction = (hydratedTransaction) => {
@@ -681,11 +820,14 @@ export {
   BalancesStepSummarySchema,
   CHANGE_ADDRESS,
   COIN_TYPES,
-  ConfigSchema,
+  ConfigZod,
   DEFAULT_WALLET_PATH,
-  MnemonicStringSchema,
+  GlobalMetaSchema,
+  JSONSchemaMetaSchema,
+  MnemonicStringZod,
   StepSummarySchema,
   TODO,
+  UsageMetaSchema,
   WALLET_COMPLIANCE,
   Xl1CommonConfigSchema,
   allHashesPresent,
@@ -720,6 +862,7 @@ export {
   isLocalhost,
   isNegativeBigInt,
   isPositiveBigInt,
+  isUsageMeta,
   netBalancesForPayloads,
   parseSignedBigInt,
   signTransaction,