@xyo-network/xl1-protocol-sdk 1.23.21 → 1.24.2

package/dist/neutral/config/actors/Mempool.d.ts

@@ -1,76 +0,0 @@
-import { z } from 'zod';
-export declare const MempoolConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<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>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    enabled: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>, z.ZodTransform<boolean, string | boolean>>;
-    host: z.ZodDefault<z.ZodString>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-export type MempoolConfig = z.infer<typeof MempoolConfigZod>;
-//# sourceMappingURL=Mempool.d.ts.map

package/dist/neutral/config/actors/Mempool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Mempool.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/Mempool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpB,CAAA;AAET,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/neutral/config/actors/Producer.d.ts

@@ -1,84 +0,0 @@
-import { z } from 'zod';
-export declare const ProducerConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<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>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>>>>;
-    disableIntentRedeclaration: z.ZodOptional<z.ZodBoolean>;
-    healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    heartbeatInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    minStake: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    rewardAddress: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ProducerConfig = z.infer<typeof ProducerConfigZod>;
-//# sourceMappingURL=Producer.d.ts.map

package/dist/neutral/config/actors/Producer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Producer.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/Producer.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDrB,CAAA;AAET,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/config/actors/RewardRedemption.d.ts

@@ -1,75 +0,0 @@
-import { z } from 'zod';
-export declare const RewardRedemptionConfigZod: z.ZodObject<{
-    chain: z.ZodDefault<z.ZodObject<{
-        id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>;
-    }, z.core.$strip>>;
-    evm: z.ZodDefault<z.ZodObject<{
-        chainId: z.ZodOptional<z.ZodString>;
-        infura: z.ZodOptional<z.ZodObject<{
-            projectId: z.ZodOptional<z.ZodString>;
-            projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        jsonRpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    log: z.ZodDefault<z.ZodObject<{
-        logLevel: z.ZodDefault<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    remote: z.ZodDefault<z.ZodObject<{
-        rpc: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    storage: z.ZodDefault<z.ZodObject<{
-        mongo: z.ZodOptional<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>;
-        }, z.core.$strip>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    telemetry: z.ZodDefault<z.ZodObject<{
-        metrics: z.ZodOptional<z.ZodObject<{
-            scrape: z.ZodObject<{
-                path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: z.ZodOptional<z.ZodObject<{
-            otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodDefault<z.ZodObject<{
-        allowedRewardRedeemers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-        allowedRewardEscrowAccountSigners: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>>>>;
-    }, z.core.$strip>>;
-    host: z.ZodDefault<z.ZodString>;
-    mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-export type RewardRedemptionConfig = z.infer<typeof RewardRedemptionConfigZod>;
-//# sourceMappingURL=RewardRedemption.d.ts.map

package/dist/neutral/config/actors/RewardRedemption.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RewardRedemption.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/RewardRedemption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkB7B,CAAA;AAET,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA"}

package/dist/neutral/config/actors/index.d.ts

@@ -1,7 +0,0 @@
-export * from './Api.ts';
-export * from './Api.ts';
-export * from './Bridge.ts';
-export * from './Mempool.ts';
-export * from './Producer.ts';
-export * from './RewardRedemption.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/neutral/config/actors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/config/actors/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,uBAAuB,CAAA"}

package/src/actor/Actor.ts

@@ -1,216 +0,0 @@
-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, ConfigZod } from '../config/index.ts'
-import { CreatableProviderFactory, ProviderFactoryLocator } from '../CreatableProvider/index.ts'
-import { ActorContext } from './ActorContext.ts'
-
-/** @deprecated use ActorParamsV2 */
-export type ActorParams<T extends EmptyObject | void = void> = CreatableParams & {
-  account: AccountInstance
-  context?: ActorContext
-  displayName?: string
-  id: string
-} & (T extends void ? EmptyObject : T)
-
-/** @deprecated use ActorInstanceV2 */
-// eslint-disable-next-line @typescript-eslint/no-deprecated
-export type ActorInstance<T extends ActorParams = ActorParams> = CreatableInstance<T>
-
-/** @deprecated use Actor */
-@creatable()
-// eslint-disable-next-line @typescript-eslint/no-deprecated
-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 defaultFactories(): CreatableProviderFactory[] {
-    return []
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  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,
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    } satisfies ActorParams
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  protected static initContext<T extends ActorInstance>(
-    params: T['params'],
-  ): Promisable<ActorContext> {
-    const logger = params?.context?.logger
-
-    const config: Config = params?.context?.config ?? ConfigZod.parse({})
-    const singletons = params?.context?.singletons ?? {}
-
-    const locator = params.context?.locator ?? new ProviderFactoryLocator({
-      ...params?.context,
-      caches: params.context?.caches ?? {},
-      config,
-      logger,
-      singletons,
-    })
-    locator.registerMany(this.defaultFactories())
-    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/ActorContext.ts

@@ -1,9 +0,0 @@
-import type { CachingContext } from '@xyo-network/xl1-protocol'
-
-import type { Config } from '../config/index.ts'
-import type { ProviderFactoryLocatorInstance } from '../CreatableProvider/index.ts'
-
-export interface ActorContext extends CachingContext {
-  config: Config
-  locator: ProviderFactoryLocatorInstance
-}

package/src/actor/ActorV2.ts

@@ -1,171 +0,0 @@
-import type {
-  CreatableInstance, CreatableParams, EmptyObject,
-  Logger,
-  Promisable,
-} from '@xylabs/sdk-js'
-import {
-  AbstractCreatable,
-  assertEx,
-  Base, delay, IdLogger,
-} from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/account-model'
-import { Semaphore } from 'async-mutex'
-
-import type { Config } from '../config/index.ts'
-import type { ProviderFactoryLocatorInstance } from '../CreatableProvider/index.ts'
-import type { ActorContext } from './ActorContext.ts'
-
-export type ActorParamsV2<T extends EmptyObject | void = void> = CreatableParams & {
-  account: AccountInstance
-  config: Config
-  logger?: Logger
-} & (T extends void ? EmptyObject : T)
-
-export type ActorInstanceV2<T extends ActorParamsV2 = ActorParamsV2> = CreatableInstance<T>
-
-export abstract class ActorV2<TParams extends ActorParamsV2 = ActorParamsV2> 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 _context!: ActorContext
-
-  protected get account() {
-    return this.params.account
-  }
-
-  protected get config() {
-    return this.params.config
-  }
-
-  protected get context() {
-    return this._context
-  }
-
-  protected get locator() {
-    return this.context.locator
-  }
-
-  static override async paramsHandler<T extends ActorInstanceV2>(params: Partial<T['params']>) {
-    const baseParams = await super.paramsHandler({ ...params, name: params.name ?? 'UnknownActor' })
-    const account = assertEx(params.account, () => `Account is required for actor ${baseParams.name}.`)
-    const config = assertEx(params.config, () => `Config is required for actor ${baseParams.name}.`)
-    const inLogger = params.logger ?? Base.defaultLogger
-    const logger = inLogger ? new IdLogger(inLogger, () => `[${baseParams.name}] `) : undefined
-    return {
-      ...baseParams, account, logger, config,
-    } satisfies ActorParamsV2
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._context = await this.initContext()
-  }
-
-  /**
-   * 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.status !== 'starting') {
-      this.logger?.warn(
-        `Cannot register timer '${timerName}' because actor is not starting.`,
-      )
-      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.status !== 'started' || !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 deactivated.
-   * Stop all running timers.
-   */
-  override async stopHandler() {
-    await super.stopHandler()
-    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.')
-  }
-
-  protected async initContext(): Promise<ActorContext> {
-    const locator = await this.initLocator()
-    return locator.context
-  }
-
-  abstract initLocator(): Promisable<ProviderFactoryLocatorInstance>
-}