@xyo-network/xl1-protocol-sdk 1.18.0 → 1.18.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol-sdk",
-  "version": "1.18.0",
+  "version": "1.18.2",
   "description": "XYO Layer One SDK Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -40,37 +40,39 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@xylabs/hex": "~5.0.51",
-    "@xylabs/sdk-js": "~5.0.51",
-    "@xylabs/zod": "~5.0.51",
-    "@xyo-network/account": "~5.2.17",
-    "@xyo-network/account-model": "~5.2.17",
-    "@xyo-network/archivist-model": "~5.2.17",
-    "@xyo-network/boundwitness-builder": "~5.2.17",
-    "@xyo-network/boundwitness-model": "~5.2.17",
-    "@xyo-network/payload-builder": "~5.2.17",
-    "@xyo-network/payload-model": "~5.2.17",
-    "@xyo-network/wallet": "~5.2.17",
-    "@xyo-network/wallet-model": "~5.2.17",
-    "@xyo-network/xl1-protocol": "~1.14.17",
+    "@xylabs/hex": "~5.0.61",
+    "@xylabs/sdk-js": "~5.0.61",
+    "@xylabs/zod": "~5.0.61",
+    "@xyo-network/account": "~5.2.19",
+    "@xyo-network/account-model": "~5.2.19",
+    "@xyo-network/archivist-model": "~5.2.19",
+    "@xyo-network/boundwitness-builder": "~5.2.19",
+    "@xyo-network/boundwitness-model": "~5.2.19",
+    "@xyo-network/payload-builder": "~5.2.19",
+    "@xyo-network/payload-model": "~5.2.19",
+    "@xyo-network/wallet": "~5.2.19",
+    "@xyo-network/wallet-model": "~5.2.19",
+    "@xyo-network/xl1-protocol": "~1.18.2",
     "async-mutex": "~0.5.0",
     "ethers": "^6.16.0",
     "lru-cache": "^11.2.4",
-    "zod": "~4.1.13"
+    "zod": "~4.2.1"
   },
   "devDependencies": {
-    "@types/node": "~25.0.2",
-    "@xylabs/events": "~5.0.51",
+    "@types/node": "~25.0.3",
+    "@xylabs/events": "~5.0.61",
     "@xylabs/ts-scripts-yarn3": "~7.2.32",
     "@xylabs/tsconfig": "~7.2.32",
-    "@xylabs/vitest-extended": "~5.0.51",
-    "@xyo-network/account": "~5.2.17",
-    "@xyo-network/archivist-mongodb": "~5.2.17",
-    "@xyo-network/boundwitness-validator": "~5.2.17",
+    "@xylabs/vitest-extended": "~5.0.61",
+    "@xyo-network/account": "~5.2.19",
+    "@xyo-network/archivist-memory": "~5.2.19",
+    "@xyo-network/archivist-mongodb": "~5.2.19",
+    "@xyo-network/boundwitness-validator": "~5.2.19",
     "axios": "^1.13.2",
     "eslint": "^9.39.2",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.15"
+    "vitest": "~4.0.16"
   },
   "peerDependencies": {
     "axios": "^1.13.2"

package/src/CreatableProvider/AbstractCreatableProvider.ts

@@ -3,15 +3,20 @@ import { AbstractCreatable, assertEx } from '@xylabs/sdk-js'
 import type { Provider, ProviderMoniker } from '../model/index.ts'
 import type {
   CreatableProvider,
-  CreatableProviderEventData, CreatableProviderFactory, CreatableProviderInstance, CreatableProviderParams,
+  CreatableProviderEventData, CreatableProviderInstance, CreatableProviderParams,
+  ProviderMap,
 } from './CreatableProvider.ts'
 import { ProviderFactory } from './ProviderFactory.ts'
 
 export abstract class AbstractCreatableProvider<TParams extends CreatableProviderParams = CreatableProviderParams,
   TEventData extends CreatableProviderEventData = CreatableProviderEventData> extends AbstractCreatable<TParams, TEventData>
   implements Omit<CreatableProviderInstance, 'moniker'> {
+  dependencies: ProviderMap = {}
+
   protected _contextCache: TParams['context'] | undefined
 
+  abstract readonly moniker: ProviderMoniker
+
   protected get config() {
     return this.context.config!
   }
@@ -24,11 +29,12 @@ export abstract class AbstractCreatableProvider<TParams extends CreatableProvide
     return this.context.locator!
   }
 
-  static factory<TModule extends CreatableProviderInstance>(
-    this: CreatableProvider<TModule>,
-    params?: Partial<TModule['params']>,
-  ): CreatableProviderFactory<TModule> {
-    const factory = ProviderFactory.withParams<TModule>(this, params)
+  static factory<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[] = ProviderMoniker[]>(
+    this: CreatableProvider<TInstance>,
+    dependencies: TDependencies,
+    params?: Partial<TInstance['params']>,
+  ) {
+    const factory = ProviderFactory.withParams<TInstance, TDependencies>(this, dependencies, params)
     return factory
   }
 

package/src/CreatableProvider/CreatableProvider.ts

@@ -27,18 +27,25 @@ export interface CreatableProviderParams<TContext extends CreatableProviderConte
 }
 export interface CreatableProviderEventData extends EventData {}
 
-export type CreatableProviderInstance<TProvider extends Provider<ProviderMoniker> = Provider<ProviderMoniker>,
+export type CreatableProviderInstance<
+  TProvider extends Provider<ProviderMoniker> = Provider<ProviderMoniker>,
+  TDependencies extends ProviderMoniker[] = ProviderMoniker[],
   TParams extends CreatableProviderParams = CreatableProviderParams,
   TEventData extends CreatableProviderEventData = CreatableProviderEventData>
-  = CreatableInstance<TParams, TEventData> & TProvider
+  = CreatableInstance<TParams, TEventData> & TProvider & {
+    dependencies: ProviderMap<TDependencies[number]>
+  }
 
 export type ProviderFactoryScope = 'global' | 'context' | 'local'
 
-export interface CreatableProviderFactory<T extends CreatableProviderInstance = CreatableProviderInstance>
+export interface CreatableProviderFactory<T extends CreatableProviderInstance = CreatableProviderInstance,
+  TDependencies extends ProviderMoniker[] = ProviderMoniker[]>
   extends Omit<CreatableProvider<T>, 'create' | 'createHandler' | 'paramsHandler'> {
   creatableProvider: CreatableProvider<T>
   defaultParams?: Partial<T['params']>
 
+  readonly dependencies: TDependencies
+
   labels?: Labels
   resolvedMoniker: string
   scope: ProviderFactoryScope
@@ -58,14 +65,19 @@ export interface CreatableProviderFactory<T extends CreatableProviderInstance =
 
 }
 
-export interface LabeledCreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance> extends CreatableProvider<T>, WithOptionalLabels {
-  factory(params?: Partial<T['params'] & CreatableProviderParams>): LabeledCreatableProviderFactory<T>
+export interface LabeledCreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance,
+  TDependencies extends ProviderMoniker[] = ProviderMoniker[]> extends CreatableProvider<T>, WithOptionalLabels {
+  factory(dependencies: TDependencies, params?: Partial<T['params'] & CreatableProviderParams>): LabeledCreatableProviderFactory<T>
 }
 
-export interface CreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance> extends Creatable<T> {
-  defaultMoniker: ProviderMoniker
-  monikers: ProviderMoniker[]
-  factory(params?: Partial<T['params'] & CreatableProviderParams>): CreatableProviderFactory<T>
+export type ProviderMap<T extends ProviderMoniker = ProviderMoniker> = Partial<Record<T, CreatableProviderInstance<Provider<T>>>>
+
+export interface CreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance,
+  TDependencies extends ProviderMoniker[] = ProviderMoniker[]> extends Creatable<T> {
+  readonly defaultMoniker: ProviderMoniker
+  readonly dependencies: TDependencies
+  readonly monikers: ProviderMoniker[]
+  factory(dependencies: TDependencies, params?: Partial<T['params'] & CreatableProviderParams>): CreatableProviderFactory<T>
 }
 
 /**

package/src/CreatableProvider/CreatableProviderRegistry.ts

@@ -5,9 +5,8 @@ import type { ProviderMoniker } from '../model/index.ts'
 import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
 import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
 
-export interface CreatableProviderRegistry {
-  [key: string]: (CreatableProviderFactory | LabeledCreatableProviderFactory)[] | undefined
-}
+export type CreatableProviderRegistry<TMonikers extends ProviderMoniker[] = ProviderMoniker[]>
+  = Record<TMonikers[number], (CreatableProviderFactory | LabeledCreatableProviderFactory)[] | undefined>
 
 const buildProviderFactory = <TProvider extends CreatableProviderInstance>(
   provider: CreatableProviderFactory<TProvider>,
@@ -22,6 +21,7 @@ const buildProviderFactory = <TProvider extends CreatableProviderInstance>(
     // Merge module & supplied labels
     labels: { ...(provider as LabeledCreatableProviderFactory).labels, ...labels },
     creatableProvider: provider.creatableProvider,
+    dependencies: provider.dependencies,
     resolvedMoniker: provider.resolvedMoniker,
     scope: provider.scope,
     getInstance: provider.getInstance.bind(provider) as LabeledCreatableProviderFactory<TProvider>['getInstance'],

package/src/CreatableProvider/ProviderFactory.ts

@@ -1,6 +1,7 @@
 import type { Labels, WithOptionalLabels } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
 
+import type { ProviderMoniker } from '../model/index.ts'
 import type {
   CreatableProvider, CreatableProviderFactory, CreatableProviderInstance,
   ProviderFactoryScope,
@@ -10,13 +11,16 @@ declare global {
   var xyoServiceSingletons: Record<string, unknown>
 }
 
-export class ProviderFactory<TProvider extends CreatableProviderInstance> implements CreatableProviderFactory<TProvider> {
+export class ProviderFactory<TProvider extends CreatableProviderInstance,
+  TDependencies extends ProviderMoniker[]> implements CreatableProviderFactory<TProvider> {
   creatableProvider: CreatableProvider<TProvider>
 
   defaultMoniker: CreatableProvider<TProvider>['monikers'][number]
 
   defaultParams?: Partial<TProvider['params']>
 
+  dependencies: TDependencies
+
   labels?: Labels
 
   monikers: CreatableProvider<TProvider>['monikers']
@@ -25,6 +29,7 @@ export class ProviderFactory<TProvider extends CreatableProviderInstance> implem
 
   constructor(
     creatableProvider: CreatableProvider<TProvider>,
+    dependencies: TDependencies,
     params?: Partial<TProvider['params']>,
     labels: Labels = {},
     scope: ProviderFactoryScope = 'context',
@@ -32,6 +37,7 @@ export class ProviderFactory<TProvider extends CreatableProviderInstance> implem
     this.creatableProvider = creatableProvider
     this.defaultParams = params
     this.defaultMoniker = creatableProvider.defaultMoniker
+    this.dependencies = dependencies
     this.monikers = creatableProvider.monikers
     this.scope = scope
     assertEx(this.monikers.includes(this.defaultMoniker), () => 'defaultMoniker must be in monikers')
@@ -44,12 +50,13 @@ export class ProviderFactory<TProvider extends CreatableProviderInstance> implem
     return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`
   }
 
-  static withParams<T extends CreatableProviderInstance>(
-    creatableProvider: CreatableProvider<T>,
-    params?: Partial<T['params']>,
+  static withParams<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
+    creatableProvider: CreatableProvider<TInstance>,
+    dependencies: TDependencies,
+    params?: Partial<TInstance['params']>,
     labels: Labels = {},
   ) {
-    return new ProviderFactory<T>(creatableProvider, params, labels)
+    return new ProviderFactory<TInstance, TDependencies>(creatableProvider, dependencies, params, labels)
   }
 
   /** @deprecated use getInstance instead */
@@ -57,12 +64,13 @@ export class ProviderFactory<TProvider extends CreatableProviderInstance> implem
     return await this.getInstance(params as TProvider['params'], start)
   }
 
-  factory<T extends CreatableProviderInstance>(
-    this: CreatableProviderFactory<T>,
-    params?: Partial<T['params']>,
+  factory<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
+    this: CreatableProviderFactory<TInstance, TDependencies>,
+    dependencies: TDependencies,
+    params?: Partial<TInstance['params']>,
     labels: Labels = {},
-  ): CreatableProviderFactory<T> {
-    return new ProviderFactory<T>(this.creatableProvider, params, labels)
+  ) {
+    return new ProviderFactory<TInstance, TDependencies>(this.creatableProvider, dependencies, params, labels)
   }
 
   async getInstance(this: CreatableProviderFactory<TProvider>, params: TProvider['params'], start = true): Promise<TProvider> {

package/src/CreatableProvider/ProviderFactoryLocator.ts

@@ -12,15 +12,16 @@ import type { ProviderFactoryLocatorInstance } from './ProviderFactoryLocatorIns
 /**
  * A class which encapsulates the Service Locator Pattern for Provider Factories
  */
-export class ProviderFactoryLocator implements ProviderFactoryLocatorInstance {
-  protected readonly _context: CreatableProviderContext
-  protected readonly _registry: CreatableProviderRegistry
+export class ProviderFactoryLocator<TContext extends CreatableProviderContext = CreatableProviderContext,
+  TMonikers extends ProviderMoniker[] = ProviderMoniker[]> implements ProviderFactoryLocatorInstance<TContext> {
+  protected readonly _context: TContext
+  protected readonly _registry: CreatableProviderRegistry<TMonikers>
 
   private _frozen = false
 
-  constructor(context: Omit<CreatableProviderContext, 'locator'>, registry: CreatableProviderRegistry = {}) {
+  constructor(context: Omit<TContext, 'locator'>, registry: CreatableProviderRegistry = {}) {
     this._registry = registry
-    this._context = { ...context, locator: this }
+    this._context = { ...context, locator: this } as unknown as TContext
   }
 
   get context() {

package/src/CreatableProvider/ProviderFactoryLocatorInstance.ts

@@ -1,11 +1,15 @@
 import type { Labels } from '@xylabs/sdk-js'
 
 import type { Provider, ProviderMoniker } from '../model/index.ts'
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
+import type {
+  CreatableProviderContext, CreatableProviderFactory, CreatableProviderInstance,
+} from './CreatableProvider.ts'
 import type { CreatableProviderRegistry } from './CreatableProviderRegistry.ts'
 import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
 
-export interface ProviderFactoryLocatorInstance {
+export interface ProviderFactoryLocatorInstance<T extends CreatableProviderContext = CreatableProviderContext> {
+
+  context: T
 
   /**
    * The current registry for the module factory

package/src/actor/Actor.ts

@@ -0,0 +1,209 @@
+import type {
+  CreatableInstance, CreatableParams, EmptyObject,
+  Promisable,
+} from '@xylabs/sdk-js'
+import {
+  AbstractCreatable,
+  assertEx,
+  Base, creatable, delay, IdLogger,
+} from '@xylabs/sdk-js'
+import { AccountInstance } from '@xyo-network/account-model'
+import { Semaphore } from 'async-mutex'
+
+import { Config, getDefaultConfig } from '../config/index.ts'
+import { ProviderFactoryLocator, ProviderFactoryLocatorInstance } from '../CreatableProvider/index.ts'
+import { BaseContext } from '../model/index.ts'
+
+export type ActorContext = BaseContext & {
+  config: Config
+  locator?: ProviderFactoryLocatorInstance
+  singletons: Record<string, unknown>
+}
+
+export type ActorParams<T extends EmptyObject | void = void> = CreatableParams & {
+  account: AccountInstance
+  context?: ActorContext
+  displayName?: string
+  id: string
+} & (T extends void ? EmptyObject : T)
+
+export type ActorInstance<T extends ActorParams = ActorParams> = CreatableInstance<T>
+
+@creatable()
+export class Actor<TParams extends ActorParams = ActorParams> extends AbstractCreatable<TParams> {
+  protected readonly _intervals: Map<string, ReturnType<typeof setInterval>> = new Map()
+  protected readonly _semaphores: Map<string, Semaphore> = new Map()
+  protected readonly _timeouts: Map<string, ReturnType<typeof setTimeout>> = new Map()
+  private _active = false
+
+  get displayName() {
+    return this.params.displayName ?? this.params.name ?? 'UnnamedActor'
+  }
+
+  get id() {
+    return this.params.id
+  }
+
+  protected get account() {
+    return this.params.account!
+  }
+
+  protected get config() {
+    return this.context.config
+  }
+
+  protected get context() {
+    return this.params.context!
+  }
+
+  protected get locator() {
+    return this.context.locator
+  }
+
+  protected get logPrefix() {
+    return `[${this.displayName} (${this.id})] `
+  }
+
+  static override async paramsHandler<T extends ActorInstance>(params?: Partial<T['params']>) {
+    const baseParams = await super.paramsHandler(params)
+    const id = params?.id ?? baseParams.name ?? 'UnnamedActor'
+    const displayName = params?.displayName ?? baseParams.name
+    const account = assertEx(params?.account, () => `Account is required for actor ${id}.`)
+    const context = await this.initContext({
+      ...params, account, id, displayName,
+    })
+    const logger = context?.logger ?? new IdLogger(Base.defaultLogger ?? console, () => `[${displayName} (${id})] `)
+    return {
+      ...baseParams, account, context, displayName, id, logger,
+    } satisfies ActorParams
+  }
+
+  protected static initContext<T extends ActorInstance>(
+    params: T['params'],
+  ): Promisable<T['params']['context']> {
+    const logger = params?.context?.logger
+    const config: Config = params?.context?.config ?? getDefaultConfig()
+    const singletons = params?.context?.singletons ?? {}
+
+    const context: ActorContext = {
+      ...params?.context,
+      config,
+      logger,
+      singletons,
+    }
+
+    const locator = params?.context?.locator ?? new ProviderFactoryLocator(context)
+    return locator.context
+  }
+
+  /**
+   * The timer runs until the actor is deactivated (or you manually stop it).
+   */
+  registerTimer(timerName: string, callback: () => Promise<void>, dueTimeMs: number, periodMs: number) {
+    if (!this._active) {
+      this.logger?.warn(
+        `Cannot register timer '${timerName}' because actor is not active.`,
+      )
+      return
+    }
+
+    let running = false
+
+    this._semaphores.set(timerName, new Semaphore(1))
+
+    const timeoutId = setTimeout(() => {
+      const intervalId = setInterval(() => {
+        const semaphore = this._semaphores.get(timerName)
+        if (!this._active || !this._intervals.has(timerName) || !semaphore || running) return
+        if (semaphore.isLocked()) {
+          this.logger?.warn(
+            `Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`,
+          )
+          return
+        }
+        semaphore.acquire().then(([, release]) => {
+          const startTime = Date.now()
+          running = true
+          callback()
+            .then(() => {
+              const duration = Date.now() - startTime
+              if (duration > periodMs) {
+                this.logger?.warn(
+                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`,
+                )
+              } else if (duration > 5000) {
+                this.logger?.warn(
+                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`,
+                )
+              }
+            })
+            .catch((error) => {
+              this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`)
+              this.logger?.error(error.stack)
+            })
+            .finally(() => {
+              release()
+              running = false
+            })
+        }).catch((error) => {
+          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`)
+        })
+      }, periodMs)
+
+      // store interval so we can clear it on stop()
+      this._intervals.set(timerName, intervalId)
+    }, dueTimeMs)
+
+    // store timeout so we can clear it on stop() if interval hasn't started yet
+    this._timeouts.set(timerName, timeoutId)
+
+    this.logger?.log(
+      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`,
+    )
+  }
+
+  /**
+   * Called by the Orchestrator when the actor is activated.
+   */
+  override async startHandler() {
+    await super.startHandler()
+    this._active = true
+    this.logger?.log('Started.')
+  }
+
+  /**
+   * Called by the Orchestrator when the actor is deactivated.
+   * Stop all running timers.
+   */
+  override async stopHandler() {
+    await super.stopHandler()
+    this._active = false
+    this.logger?.log('Stopping all timers...')
+
+    // wait for all semaphores to be free and acquire them to prevent new tasks from starting
+    await Promise.all(
+      [...this._semaphores.values()].map(async (semaphore) => {
+        // Wait for any running tasks to complete
+        while (semaphore.isLocked()) {
+          this.logger?.log('Waiting for running timer task to complete...')
+          await delay(500)
+        }
+        await semaphore.acquire()
+      }),
+    )
+
+    this._semaphores.clear()
+
+    for (const [, timeoutRef] of this._timeouts.entries()) {
+      clearTimeout(timeoutRef)
+    }
+    this._timeouts.clear()
+
+    for (const [, intervalRef] of this._intervals.entries()) {
+      clearInterval(intervalRef)
+    }
+    this._intervals.clear()
+
+    this.logger?.log('Stopped.')
+  }
+}

package/src/actor/index.ts

@@ -0,0 +1 @@
+export * from './Actor.ts'

package/src/block/hydrate/allHashesPresent.ts

@@ -1,7 +1,7 @@
 import type { Hash } from '@xylabs/sdk-js'
-import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 
-export function allHashesPresent(hashes: Hash[], payloads: WithStorageMeta<Payload>[]): boolean {
+export function allHashesPresent(hashes: Hash[], payloads: WithHashMeta<Payload>[]): boolean {
   const payloadHashes = new Set(payloads.map(p => p._hash))
   return hashes.every(hash => payloadHashes.has(hash))
 }

package/src/block/hydrate/hydrateBlock.ts

@@ -1,6 +1,6 @@
 import type { Hash } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
-import type { HydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol'
 import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
 
 import type { ChainStoreRead } from '../../model/index.ts'
@@ -11,7 +11,7 @@ export const hydrateBlock = async (
   hash: Hash,
   maxDepth: number = 1,
   minDepth = maxDepth,
-): Promise<HydratedBlockWithHashMeta> => {
+): Promise<HydratedBlockWithStorageMeta> => {
   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')

package/src/config/Api.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Bridge.ts

@@ -3,8 +3,7 @@ import {
 } from '@xylabs/hex'
 import type { ChainId } from '@xyo-network/xl1-protocol'
 import { AttoXL1ConvertFactor, XL1 } from '@xyo-network/xl1-protocol'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Chain.ts

@@ -1,6 +1,5 @@
 import { AddressZod, HexZod } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const ChainConfigZod = z.object({
   id: HexZod.optional()

package/src/config/Config.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod'
+import { z } from 'zod'
 
 import { ApiConfigZod } from './Api.ts'
 import { BridgeConfigZod } from './Bridge.ts'

package/src/config/Evm.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const EvmInfuraConfigZod = z.object({
   projectId: z.string().optional().register(globalRegistry, {

package/src/config/Log.ts

@@ -1,7 +1,6 @@
 import type { LogLevelKey } from '@xylabs/sdk-js'
 import { LogLevel } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 const LogLevels = Object.keys(LogLevel) as [LogLevelKey, ...LogLevelKey[]]
 
 export const LogConfigZod = z.object({

package/src/config/Mempool.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Producer.ts

@@ -1,6 +1,5 @@
 import { AddressZod, asAddress } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/RewardRedemptionApi.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Services.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const ServicesConfigZod = z.object({
   accountBalanceViewerEndpoint: z.string().default('http://localhost:8080/rpc').register(globalRegistry, {