@xyo-network/chain-orchestration 1.19.18 → 1.20.0

package/dist/browser/index.mjs

@@ -0,0 +1,967 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/shared/actor/ValidatorActor.ts
+import { creatable } from "@xylabs/sdk-js";
+import { processPendingBlocks } from "@xyo-network/chain-sdk";
+import { ActorV3, BlockViewerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var ValidatorActor = class extends ActorV3 {
+  static {
+    __name(this, "ValidatorActor");
+  }
+  _blockViewer;
+  _finalizationRunner;
+  _lastValidatedBlock;
+  _lastValidatedBlockHash;
+  _mempoolViewer;
+  get blockViewer() {
+    return this._blockViewer;
+  }
+  get finalizationRunner() {
+    return this._finalizationRunner;
+  }
+  get mempoolViewer() {
+    return this._mempoolViewer;
+  }
+  async createHandler() {
+    await super.startHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+    this._finalizationRunner = await this.locator.getInstance(FinalizationRunnerMoniker);
+    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker);
+  }
+  async startHandler() {
+    await super.startHandler();
+    this.registerTimer(
+      "ValidatorActor",
+      async () => {
+        await this.spanAsync("processPendingBlocks", async () => {
+          console.log("ValidatorActor: Processing pending blocks...");
+          await processPendingBlocks({
+            context: this.context,
+            logger: this.logger,
+            mempoolViewer: this.mempoolViewer,
+            blockViewer: this.blockViewer,
+            finalizationRunner: this.finalizationRunner
+          });
+        }, {
+          ...this.context,
+          timeBudgetLimit: 1500
+        });
+      },
+      2e3,
+      1500
+      /* 500 */
+    );
+  }
+};
+ValidatorActor = _ts_decorate([
+  creatable()
+], ValidatorActor);
+
+// src/shared/buildTelemetryConfig.ts
+function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetricsScrapePort = 9464) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = defaultMetricsScrapePort } = config.telemetry?.metrics?.scrape ?? {};
+  const telemetryConfig = {
+    attributes: {
+      serviceName,
+      serviceVersion
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  };
+  return telemetryConfig;
+}
+__name(buildTelemetryConfig, "buildTelemetryConfig");
+
+// src/shared/config/actors/Api.ts
+import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/sdk-js";
+import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
+import { globalRegistry, z } from "zod";
+var ApiConfigZod = HostActorConfigZod.extend(z.object({
+  initRewardsCache: z.union([
+    z.number(),
+    z.string(),
+    z.boolean()
+  ]).transform((v) => v !== "0" && v !== "false" && v !== false && v != 0).default(true).register(globalRegistry, {
+    description: "Whether to initialize the rewards cache on startup",
+    title: "api.initRewardsCache",
+    type: "boolean"
+  })
+}).shape);
+var isApiConfig = zodIsFactory(ApiConfigZod);
+var asApiConfig = zodAsFactory(ApiConfigZod, "asApiConfig");
+var toApiConfig = zodToFactory(ApiConfigZod, "toApiConfig");
+var ApiConfigContext = BaseConfigContextZod.extend({
+  config: ApiConfigZod
+});
+var isApiConfigContext = zodIsFactory(ApiConfigContext);
+var asApiConfigContext = zodAsFactory(ApiConfigContext, "asApiConfigContext");
+var toApiConfigContext = zodToFactory(ApiConfigContext, "toApiConfigContext");
+
+// src/shared/config/actors/Bridge.ts
+import { AddressZod, HexZod, toAddress, toHex, zodAsFactory as zodAsFactory2, zodIsFactory as zodIsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/sdk-js";
+import { AttoXL1ConvertFactor, BaseConfigContextZod as BaseConfigContextZod2, HostActorConfigZod as HostActorConfigZod2, XL1 } from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry2, z as z2 } from "zod";
+var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
+var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
+var DEFAULT_HARDHAT_CHAIN_ID = toHex("7A69");
+var DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f64180aa3");
+var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(100000000n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
+var BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
+var BridgeConfigZod = HostActorConfigZod2.extend({
+  escrowAddress: AddressZod.optional().register(globalRegistry2, {
+    description: "Address to which bridge escrow will be sent",
+    title: "bridge.escrowAddress",
+    type: "string"
+  }),
+  feesAddress: AddressZod.optional().register(globalRegistry2, {
+    description: "Address to which bridge fees will be sent",
+    title: "bridge.feesAddress",
+    type: "string"
+  }),
+  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry2, {
+    default: DEFAULT_FIXED_FEE,
+    description: "Fixed fee (in AttoXL1) applied to bridge transfers",
+    title: "bridge.feeFixed",
+    type: "bigint"
+  }),
+  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
+    default: DEFAULT_VARIABLE_FEE_BASIS_POINTS,
+    description: "Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers",
+    title: "bridge.feeRateBasisPoints",
+    type: "number"
+  }),
+  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry2, {
+    default: DEFAULT_MAX_BRIDGE_AMOUNT,
+    description: "Maximum amount allowed for a bridge transfer",
+    title: "bridge.maxBridgeAmount",
+    type: "string"
+  }),
+  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry2, {
+    default: DEFAULT_MIN_BRIDGE_AMOUNT,
+    description: "Minimum amount required for a bridge transfer",
+    title: "bridge.minBridgeAmount",
+    type: "string"
+  }),
+  redisHost: z2.string().default("localhost").register(globalRegistry2, {
+    default: "localhost",
+    description: "Host for the Bridge Redis instance",
+    title: "bridge.redisHost",
+    type: "string"
+  }),
+  redisPort: z2.coerce.number().int().positive().default(6379).register(globalRegistry2, {
+    default: 6379,
+    description: "Port for the Bridge Redis instance",
+    title: "bridge.redisPort",
+    type: "number"
+  }),
+  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
+    default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
+    description: "Hex representation of remote token address used for bridging",
+    title: "bridge.remoteBridgeContractAddress",
+    type: "string"
+  }),
+  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry2, {
+    default: DEFAULT_HARDHAT_CHAIN_ID,
+    description: "Remote chain ID",
+    title: "bridge.remoteChainId",
+    type: "string"
+  }),
+  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
+    default: DEFAULT_HARDHAT_TOKEN_CONTRACT,
+    description: "Hex representation of remote token address used for bridging",
+    title: "bridge.remoteTokenAddress",
+    type: "string"
+  }),
+  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry2, {
+    description: "Private key for the wallet to use for the remote chain wallet",
+    title: "bridge.remoteChainWalletPrivateKey",
+    type: "string"
+  }),
+  xl1ChainId: HexZod.optional().register(globalRegistry2, {
+    description: "XL1 chain id used for bridging",
+    title: "bridge.xl1ChainId",
+    type: "string"
+  }),
+  xl1TokenAddress: HexZod.optional().register(globalRegistry2, {
+    description: "XL1 token address used for bridging",
+    title: "bridge.xl1TokenAddress",
+    type: "string"
+  })
+});
+var BridgeSettingsZod = BridgeConfigZod.pick({
+  feeFixed: true,
+  feeRateBasisPoints: true,
+  feesAddress: true,
+  escrowAddress: true,
+  maxBridgeAmount: true,
+  minBridgeAmount: true,
+  remoteChainId: true,
+  remoteTokenAddress: true,
+  xl1TokenAddress: true,
+  xl1ChainId: true
+}).required();
+var isBridgeConfig = zodIsFactory2(BridgeConfigZod);
+var asBridgeConfig = zodAsFactory2(BridgeConfigZod, "asBridgeConfig");
+var toBridgeConfig = zodToFactory2(BridgeConfigZod, "toBridgeConfig");
+var BridgeConfigContext = BaseConfigContextZod2.extend({
+  config: BridgeConfigZod
+});
+var isBridgeConfigContext = zodIsFactory2(BridgeConfigContext);
+var asBridgeConfigContext = zodAsFactory2(BridgeConfigContext, "asBridgeConfigContext");
+var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigContext");
+
+// src/shared/config/actors/Mempool.ts
+import { zodAsFactory as zodAsFactory3, zodIsFactory as zodIsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/sdk-js";
+import { BaseConfigContextZod as BaseConfigContextZod3, HostActorConfigZod as HostActorConfigZod3 } from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry3, z as z3 } from "zod";
+var MempoolConfigZod = HostActorConfigZod3.extend({
+  enabled: z3.union([
+    z3.string(),
+    z3.boolean()
+  ]).default("false").transform((val, ctx) => {
+    if (typeof val === "boolean") return val;
+    const normalized = val.toLowerCase().trim();
+    if ([
+      "true",
+      "1",
+      "yes",
+      "on"
+    ].includes(normalized)) return true;
+    if ([
+      "false",
+      "0",
+      "no",
+      "off"
+    ].includes(normalized)) return false;
+    ctx.addIssue({
+      code: "invalid_type",
+      expected: "boolean",
+      message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
+    });
+    return z3.NEVER;
+  }).register(globalRegistry3, {
+    default: "false",
+    description: "Enable the Mempool",
+    title: "mempool.enabled",
+    type: "boolean"
+  })
+});
+var isMempoolConfig = zodIsFactory3(MempoolConfigZod);
+var asMempoolConfig = zodAsFactory3(MempoolConfigZod, "asMempoolConfig");
+var toMempoolConfig = zodToFactory3(MempoolConfigZod, "toMempoolConfig");
+var MempoolConfigContext = BaseConfigContextZod3.extend({
+  config: MempoolConfigZod
+});
+var isMempoolConfigContext = zodIsFactory3(MempoolConfigContext);
+var asMempoolConfigContext = zodAsFactory3(MempoolConfigContext, "asMempoolConfigContext");
+var toMempoolConfigContext = zodToFactory3(MempoolConfigContext, "toMempoolConfigContext");
+
+// src/shared/config/actors/Producer.ts
+import { AddressZod as AddressZod2, asAddress, zodAsFactory as zodAsFactory4, zodIsFactory as zodIsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/sdk-js";
+import { ActorConfigZod, BaseConfigContextZod as BaseConfigContextZod4 } from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry4, z as z4 } from "zod";
+var ProducerConfigZod = ActorConfigZod.extend(z4.object({
+  allowlist: z4.preprocess((val) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress(s.trim()));
+    }
+    return val;
+  }, z4.array(AddressZod2).optional().register(globalRegistry4, {
+    description: "List of allowed producer addresses, if undefined anyone can participate",
+    title: "allowlist",
+    type: "array"
+  })),
+  disableIntentRedeclaration: z4.boolean().optional().register(globalRegistry4, {
+    description: "Should the producer skip redeclaring their intent to continue producing blocks",
+    title: "producer.disableIntentRedeclaration",
+    type: "boolean"
+  }),
+  heartbeatInterval: z4.coerce.number().default(36e5).register(globalRegistry4, {
+    description: "The number of milliseconds between heartbeats if no blocks are produced",
+    title: "producer.heartbeatInterval",
+    type: "number"
+  }),
+  // TODO: BigInt schema
+  minStake: z4.coerce.number().default(1).register(globalRegistry4, {
+    description: "Minimum stake required to be a Producer",
+    title: "producer.minStake",
+    type: "number"
+  }),
+  // TODO: Address schema
+  rewardAddress: z4.string().optional().register(globalRegistry4, {
+    description: "Address to receive block rewards",
+    title: "producer.rewardAddress",
+    type: "string"
+  })
+}).shape);
+var isProducerConfig = zodIsFactory4(ProducerConfigZod);
+var asProducerConfig = zodAsFactory4(ProducerConfigZod, "asProducerConfig");
+var toProducerConfig = zodToFactory4(ProducerConfigZod, "toProducerConfig");
+var ProducerConfigContext = BaseConfigContextZod4.extend({
+  config: ProducerConfigZod
+});
+var isProducerConfigContext = zodIsFactory4(ProducerConfigContext);
+var asProducerConfigContext = zodAsFactory4(ProducerConfigContext, "asProducerConfigContext");
+var toProducerConfigContext = zodToFactory4(ProducerConfigContext, "toProducerConfigContext");
+
+// src/shared/config/actors/RewardRedemption.ts
+import { zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/sdk-js";
+import { BaseConfigContextZod as BaseConfigContextZod5, HostActorConfigZod as HostActorConfigZod4 } from "@xyo-network/xl1-sdk";
+var RewardRedemptionConfigZod = HostActorConfigZod4.extend({});
+var isRewardRedemptionConfig = zodIsFactory5(RewardRedemptionConfigZod);
+var asRewardRedemptionConfig = zodAsFactory5(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
+var toRewardRedemptionConfig = zodToFactory5(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
+var RewardRedemptionConfigContext = BaseConfigContextZod5.extend({
+  config: RewardRedemptionConfigZod
+});
+var isRewardRedemptionConfigContext = zodIsFactory5(RewardRedemptionConfigContext);
+var asRewardRedemptionConfigContext = zodAsFactory5(RewardRedemptionConfigContext, "asRewardRedemptionConfigContext");
+var toRewardRedemptionConfigContext = zodToFactory5(RewardRedemptionConfigContext, "toRewardRedemptionConfigContext");
+
+// src/shared/config/locators/commonLocatorFromConfig.ts
+import { validateHydratedBlock, validateHydratedBlockState } from "@xyo-network/chain-validation";
+import { ProviderFactoryLocator, SimpleBlockRewardViewer, SimpleBlockValidationViewer, SimpleNetworkStakeViewer, SimpleStepRewardsByPositionViewer, SimpleStepRewardsByStakerViewer, SimpleStepRewardsByStepViewer, SimpleStepRewardsTotalViewer, SimpleStepRewardsViewer, SimpleStepViewer, SimpleTimeSyncViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer } from "@xyo-network/xl1-sdk";
+function commonLocatorFromConfig(context, validateDepsOnRegister = false) {
+  let locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister);
+  locator.registerMany([
+    SimpleNetworkStakeViewer.factory(SimpleNetworkStakeViewer.dependencies, {}),
+    SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {}),
+    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {}),
+    SimpleStepRewardsViewer.factory(SimpleStepRewardsViewer.dependencies, {}),
+    SimpleStepRewardsByPositionViewer.factory(SimpleStepRewardsByPositionViewer.dependencies, {}),
+    SimpleStepRewardsByStakerViewer.factory(SimpleStepRewardsByStakerViewer.dependencies, {}),
+    SimpleStepRewardsByStepViewer.factory(SimpleStepRewardsByStepViewer.dependencies, {}),
+    SimpleStepRewardsTotalViewer.factory(SimpleStepRewardsTotalViewer.dependencies, {}),
+    SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
+      maxWindowSize: 1e4,
+      syncInterval: 1e4
+    }),
+    SimpleBlockRewardViewer.factory(SimpleBlockRewardViewer.dependencies, {}),
+    SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
+      state: validateHydratedBlockState,
+      protocol: validateHydratedBlock
+    }),
+    SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {})
+  ]);
+  return locator;
+}
+__name(commonLocatorFromConfig, "commonLocatorFromConfig");
+
+// src/shared/init/initActorAccount.ts
+import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { HDWallet } from "@xyo-network/sdk-js";
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
+var actorAccountSingletons = {};
+async function initActorAccount({ config, logger }) {
+  const actorName = config.name;
+  if (isDefined(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName];
+  let walletPhrase = config.mnemonic;
+  if (isUndefined(walletPhrase)) {
+    logger?.warn(`[${actorName}}] No wallet mnemonic specified!`);
+    const randomMnemonic = HDWallet.generateMnemonic();
+    logger?.warn(`[${actorName}}] Using randomly generated mnemonic:
+    
+${randomMnemonic}
+      
+    `);
+    walletPhrase = randomMnemonic;
+  }
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
+  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
+  actorAccountSingletons[actorName] = account;
+  return actorAccountSingletons[actorName];
+}
+__name(initActorAccount, "initActorAccount");
+
+// src/shared/init/initActorSeedPhrase.ts
+import { assertEx, isString } from "@xylabs/sdk-js";
+import { HDWallet as HDWallet2 } from "@xyo-network/sdk-js";
+async function initActorSeedPhrase(context, bios) {
+  const { logger, config } = context;
+  const walletKind = config.name;
+  const storedSeedPhrase = await bios.seedPhraseStore.get(walletKind);
+  logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`);
+  const { mnemonic } = config;
+  if (isString(storedSeedPhrase) && isString(mnemonic)) {
+    logger?.warn("[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.");
+    await bios.seedPhraseStore.set(walletKind, mnemonic);
+  } else {
+    let seedPhrase;
+    if (isString(mnemonic)) {
+      seedPhrase = mnemonic;
+    } else {
+      seedPhrase = HDWallet2.generateMnemonic();
+      logger?.log("[API] No mnemonic provided, using random mnemonic. This is not recommended for production use.");
+      logger?.log(`[API] Mnemonic: ${seedPhrase}`);
+    }
+    await bios.seedPhraseStore.set(walletKind, seedPhrase);
+  }
+  return assertEx(await bios.seedPhraseStore.get(walletKind), () => "Unable to acquire mnemonic from bios");
+}
+__name(initActorSeedPhrase, "initActorSeedPhrase");
+
+// src/shared/init/initBridgedModule.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { asAttachableArchivistInstance, asAttachableModuleInstance } from "@xyo-network/sdk-js";
+import { Mutex } from "async-mutex";
+var initMutex = new Mutex();
+var bridgedModuleDictionary = {};
+async function initBridgedModule({ bridge, moduleName }) {
+  return await initMutex.runExclusive(async () => {
+    const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
+    if (existing) return existing;
+    const mod = assertEx2(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx2(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    let moduleMap = bridgedModuleDictionary[bridge.address];
+    if (moduleMap === void 0) {
+      moduleMap = {};
+      bridgedModuleDictionary[bridge.address] = moduleMap;
+    }
+    moduleMap[moduleName] = moduleInstance;
+    return moduleInstance;
+  });
+}
+__name(initBridgedModule, "initBridgedModule");
+async function initBridgedArchivistModule({ bridge, moduleName }) {
+  return assertEx2(asAttachableArchivistInstance(await initBridgedModule({
+    bridge,
+    moduleName
+  })), () => `Could not convert ${moduleName} to attachable archivist instance`);
+}
+__name(initBridgedArchivistModule, "initBridgedArchivistModule");
+
+// src/shared/init/initEvmProvidersIfAvailable.ts
+import { asEthAddress, assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer } from "@xyo-network/chain-ethereum";
+import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer as SimpleTimeSyncViewer2, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
+
+// src/shared/evm/initChainId.ts
+import { assertEx as assertEx3, hexFrom, isDefined as isDefined2, isHex } from "@xylabs/sdk-js";
+var canUseChainId = /* @__PURE__ */ __name(({ config }) => {
+  return isDefined2(config.evm.chainId);
+}, "canUseChainId");
+var getChainId = /* @__PURE__ */ __name(({ config }) => {
+  const chainId = assertEx3(config.evm.chainId, () => "Missing config.evm.chainId");
+  if (isHex(chainId, {
+    prefix: true
+  })) {
+    const hex = hexFrom(chainId);
+    const parsed = Number.parseInt(hex, 16);
+    return parsed;
+  } else {
+    const parsed = Number.parseInt(chainId, 10);
+    return parsed;
+  }
+}, "getChainId");
+
+// src/shared/evm/initEvmProvider.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+
+// src/shared/evm/initInfuraProvider.ts
+import { assertEx as assertEx4, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { InfuraProvider } from "ethers/providers";
+var instance;
+var initInfuraProvider = /* @__PURE__ */ __name((context) => {
+  if (instance) return instance;
+  const providerConfig = getInfuraProviderConfig(context);
+  instance = Promise.resolve(new InfuraProvider(providerConfig[0], providerConfig[1]));
+  return instance;
+}, "initInfuraProvider");
+var canUseInfuraProvider = /* @__PURE__ */ __name((context) => {
+  const { config } = context;
+  return canUseChainId(context) && isDefined3(config.evm?.infura?.projectId) && isDefined3(config.evm?.infura?.projectSecret);
+}, "canUseInfuraProvider");
+var getInfuraProviderConfig = /* @__PURE__ */ __name((context) => {
+  const { config } = context;
+  const projectId = assertEx4(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx4(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  return [
+    getChainId(context),
+    projectId,
+    projectSecret
+  ];
+}, "getInfuraProviderConfig");
+
+// src/shared/evm/initJsonRpcProvider.ts
+import { assertEx as assertEx5, isDefined as isDefined4 } from "@xylabs/sdk-js";
+import { JsonRpcProvider } from "ethers/providers";
+var initJsonRpcProvider = /* @__PURE__ */ __name((context) => {
+  const providerConfig = getJsonRpcProviderConfig(context);
+  return Promise.resolve(new JsonRpcProvider(...providerConfig));
+}, "initJsonRpcProvider");
+var canUseJsonRpcProvider = /* @__PURE__ */ __name((context) => {
+  const { config } = context;
+  return canUseChainId(context) && isDefined4(config.evm.jsonRpc?.url);
+}, "canUseJsonRpcProvider");
+var getJsonRpcProviderConfig = /* @__PURE__ */ __name((context) => {
+  const { config } = context;
+  const jsonRpcUrl = assertEx5(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  return [
+    jsonRpcUrl,
+    getChainId(context)
+  ];
+}, "getJsonRpcProviderConfig");
+
+// src/shared/evm/initEvmProvider.ts
+var provider;
+var initEvmProvider = /* @__PURE__ */ __name(async (context) => {
+  if (provider) return provider;
+  if (canUseInfuraProvider(context)) {
+    provider = initInfuraProvider(context);
+  } else if (canUseJsonRpcProvider(context)) {
+    provider = initJsonRpcProvider(context);
+  }
+  return assertEx6(await provider, () => "No provider available");
+}, "initEvmProvider");
+var canUseEvmProvider = /* @__PURE__ */ __name((context) => {
+  return canUseInfuraProvider(context) || canUseJsonRpcProvider(context);
+}, "canUseEvmProvider");
+
+// src/shared/init/initEvmProvidersIfAvailable.ts
+async function initEvmProvidersIfAvailable(locator) {
+  const context = locator.context;
+  const { logger } = context;
+  if (canUseEvmProvider(context)) {
+    const chainId = assertEx7(context.config.chain.id, () => "Missing config.chain.id (required for EVM providers)");
+    const provider2 = await initEvmProvider(context);
+    const address = asEthAddress(chainId, true);
+    locator.register(EvmStakeEventsViewer.factory(EvmStakeEventsViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(EvmStakeViewer.factory(EvmStakeViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(EvmStakeTotalsViewer.factory(EvmStakeTotalsViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(EvmChainContractViewer.factory(EvmChainContractViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {
+      ethProvider: provider2
+    }));
+  } else {
+    logger?.warn("EVM provider not available - running with memory based contract/stake viewers");
+    const positions = [];
+    locator.register(SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, {
+      positions
+    }));
+    locator.register(SimpleStakeViewer.factory(SimpleStakeViewer.dependencies, {
+      positions
+    }));
+    locator.register(SimpleStakeTotalsViewer.factory(SimpleStakeTotalsViewer.dependencies, {}));
+    locator.register(SimpleChainContractViewer.factory(SimpleChainContractViewer.dependencies, {
+      minWithdrawalBlocks: 10,
+      stakingTokenAddress: XYO_ZERO_ADDRESS,
+      rewardsContract: XYO_ZERO_ADDRESS
+    }));
+    locator.register(SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {}));
+  }
+  return locator;
+}
+__name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
+
+// src/shared/init/initStatusReporter.ts
+import { RuntimeStatusMonitor } from "@xyo-network/xl1-sdk";
+function initStatusReporter({ logger }) {
+  const statusReporter = new RuntimeStatusMonitor(logger);
+  statusReporter.onGlobalTransition({
+    to: "started"
+  }, () => {
+    logger.log("All services started.");
+  });
+  statusReporter.onGlobalTransition({
+    to: "error"
+  }, () => {
+    logger.error("Producer encountered an unhandled error!");
+    process.exit(1);
+  });
+  return statusReporter;
+}
+__name(initStatusReporter, "initStatusReporter");
+
+// src/shared/init/initWallet.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { boot } from "@xyo-network/bios";
+import { HDWallet as HDWallet3 } from "@xyo-network/sdk-js";
+async function initActorWallet(context, mnemonic) {
+  const bios = await boot();
+  const seedPhrase = isDefined5(mnemonic) ? mnemonic : await initActorSeedPhrase(context, bios);
+  return await HDWallet3.fromPhrase(seedPhrase);
+}
+__name(initActorWallet, "initActorWallet");
+
+// src/shared/config/locators/telemetryContextFromConfig.ts
+import { initTelemetry } from "@xyo-network/chain-telemetry";
+async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9466 } = config.telemetry?.metrics?.scrape ?? {};
+  return await initTelemetry({
+    attributes: {
+      serviceName,
+      serviceVersion
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  });
+}
+__name(telemetryContextFromConfig, "telemetryContextFromConfig");
+
+// src/shared/config/locators/contextFromConfigWithoutLocator.ts
+async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion) {
+  const singletons = {};
+  const caches = {};
+  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion);
+  const statusReporter = initStatusReporter({
+    logger
+  });
+  return {
+    ...telemetryConfig,
+    config,
+    singletons,
+    caches,
+    logger,
+    statusReporter
+  };
+}
+__name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
+
+// src/shared/config/locators/remoteLocatorFromConfig.ts
+import { JsonRpcAccountBalanceViewer, JsonRpcBlockViewer, JsonRpcFinalizationViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcNetworkStakeViewer, JsonRpcStakeViewer, JsonRpcTransactionViewer, JsonRpcXyoViewer, ProviderFactoryLocator as ProviderFactoryLocator2, SimpleStakeEventsViewer as SimpleStakeEventsViewer2 } from "@xyo-network/xl1-sdk";
+function remoteLocatorFromConfig(context, validateDepsOnRegister = false) {
+  const locator = new ProviderFactoryLocator2(context, {}, validateDepsOnRegister);
+  locator.registerMany([
+    JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {}),
+    JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {}),
+    JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {}),
+    JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {}),
+    JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {}),
+    JsonRpcTransactionViewer.factory(JsonRpcTransactionViewer.dependencies, {}),
+    JsonRpcNetworkStakeViewer.factory(JsonRpcNetworkStakeViewer.dependencies, {}),
+    JsonRpcStakeViewer.factory(JsonRpcStakeViewer.dependencies, {}),
+    SimpleStakeEventsViewer2.factory(SimpleStakeEventsViewer2.dependencies, {
+      positions: []
+    }),
+    JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
+  ]);
+  return locator;
+}
+__name(remoteLocatorFromConfig, "remoteLocatorFromConfig");
+
+// src/shared/config/mergeConfig.ts
+import { deepMerge } from "@xylabs/sdk-js";
+function mergeConfig({ actors, ...baseConfig }) {
+  return {
+    ...baseConfig,
+    actors: actors.map((actor) => {
+      return deepMerge(baseConfig, actor);
+    })
+  };
+}
+__name(mergeConfig, "mergeConfig");
+
+// src/shared/createDeclarationIntentBlock.ts
+import { buildNextBlock } from "@xyo-network/chain-sdk";
+import { createDeclarationIntent } from "@xyo-network/xl1-sdk";
+async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, range) {
+  const producerDeclarationPayload = createDeclarationIntent(producerAccount.address, "producer", range[0], range[1]);
+  return await buildNextBlock(prevBlock, [], [
+    producerDeclarationPayload
+  ], [
+    producerAccount
+  ]);
+}
+__name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
+
+// src/shared/host/implementation/DefaultHost.ts
+var GenericHost = class {
+  static {
+    __name(this, "GenericHost");
+  }
+  services;
+  constructor(services) {
+    this.services = services;
+  }
+  async start() {
+    await Promise.resolve();
+    console.log("Host is starting...");
+  }
+  async stop() {
+    await Promise.resolve();
+    console.log("Host is stopping...");
+  }
+};
+
+// src/shared/host/implementation/DefaultServiceProvider.ts
+var DefaultServiceProvider = class {
+  static {
+    __name(this, "DefaultServiceProvider");
+  }
+  _services;
+  constructor(services) {
+    this._services = services;
+  }
+  getService(serviceIdentifier) {
+    return this._services[serviceIdentifier];
+  }
+};
+
+// src/shared/host/model/ServiceCollection.ts
+var ServiceLifetime = {
+  Singleton: "Singleton",
+  Transient: "Transient"
+};
+
+// src/shared/orchestrator/Orchestrator.ts
+import { AbstractCreatable, creatable as creatable2 } from "@xylabs/sdk-js";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var Orchestrator = class extends AbstractCreatable {
+  static {
+    __name(this, "Orchestrator");
+  }
+  actors = [];
+  keepAliveHandle = null;
+  running = false;
+  /**
+  * Registers an actor.
+  * (We won't activate the actor until `start()` is called.)
+  */
+  async registerActor(actor) {
+    if (this.running) {
+      await actor.start();
+    }
+    this.actors.push(actor);
+  }
+  /**
+  * Starts the orchestrator: activates all actors.
+  */
+  async startHandler() {
+    await super.startHandler();
+    if (this.running) {
+      this.logger?.warn("[Orchestrator] Already started.");
+      return;
+    }
+    this.logger?.log("[Orchestrator] Starting...");
+    this.running = true;
+    for (const actor of this.actors) {
+      await actor.start();
+    }
+    this.keepAliveHandle = setInterval(() => {
+    }, 2147483647);
+  }
+  /**
+  * Stops the orchestrator: deactivates all actors.
+  */
+  async stopHandler() {
+    await super.stopHandler();
+    if (!this.running) {
+      this.logger?.log("[Orchestrator] Already stopped.");
+      return;
+    }
+    this.logger?.log("[Orchestrator] Stopping...");
+    for (const actor of this.actors) {
+      await actor.stop();
+    }
+    this.running = false;
+    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle);
+    this.logger?.log("[Orchestrator] Stopped...");
+  }
+};
+Orchestrator = _ts_decorate2([
+  creatable2()
+], Orchestrator);
+
+// src/neutral/config/locators/basicRemoteRunnerLocator.ts
+import { isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { JsonRpcXyoRunner, JsonRpcXyoSigner, ProviderFactoryLocator as ProviderFactoryLocator4, RestDataLakeViewer as RestDataLakeViewer2, SimpleXyoConnectionRunner, SimpleXyoGatewayRunner } from "@xyo-network/xl1-sdk";
+
+// src/neutral/config/locators/basicRemoteViewerLocator.ts
+import { assertEx as assertEx8, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { ActorConfigZod as ActorConfigZod2, BaseConfigZod, BlockViewerMoniker as BlockViewerMoniker2, JsonRpcBlockViewer as JsonRpcBlockViewer2, ProviderFactoryLocator as ProviderFactoryLocator3, RestDataLakeViewer, SimpleTransactionViewer as SimpleTransactionViewer2, SimpleXyoConnectionViewer, SimpleXyoGateway } from "@xyo-network/xl1-sdk";
+async function getChainIdFromRemote(remoteConfig) {
+  const locator = new ProviderFactoryLocator3({
+    config: BaseConfigZod.parse({
+      remote: remoteConfig
+    }),
+    singletons: {},
+    caches: {}
+  });
+  locator.registerMany([
+    JsonRpcBlockViewer2.factory(JsonRpcBlockViewer2.dependencies, {})
+  ]);
+  locator.freeze();
+  const blockViewer = await locator.getInstance(BlockViewerMoniker2);
+  return assertEx8(await blockViewer.chainId(), () => "Chain ID could not be determined from remote config");
+}
+__name(getChainIdFromRemote, "getChainIdFromRemote");
+async function basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint) {
+  const config = ActorConfigZod2.parse({
+    name,
+    remote: remoteConfig,
+    chain: {
+      id: chainId ?? await getChainIdFromRemote(remoteConfig)
+    }
+  });
+  const rootLocator = await commonLocatorFromConfig({
+    config,
+    singletons: {},
+    caches: {}
+  });
+  const remoteLocator = await remoteLocatorFromConfig(rootLocator.context);
+  const locator = new ProviderFactoryLocator3(remoteLocator.context, {});
+  locator.registerMany([
+    SimpleXyoGateway.factory(SimpleXyoGateway.dependencies, {}),
+    SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}),
+    SimpleTransactionViewer2.factory(SimpleTransactionViewer2.dependencies, {})
+  ]);
+  if (isDefined6(dataLakeEndpoint)) {
+    const dataLakeViewerParams = {
+      endpoint: dataLakeEndpoint
+    };
+    locator.register(RestDataLakeViewer.factory(RestDataLakeViewer.dependencies, dataLakeViewerParams));
+  }
+  locator.freeze();
+  return locator;
+}
+__name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
+
+// src/neutral/config/locators/basicRemoteRunnerLocator.ts
+async function basicRemoteRunnerLocator(name, remoteConfig, signerTransport, chainId, dataLakeEndpoint) {
+  const remoteViewerLocator = await basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint);
+  const locator = new ProviderFactoryLocator4(remoteViewerLocator.context, {});
+  locator.registerMany([
+    JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, {
+      transport: signerTransport
+    }),
+    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
+    JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {}),
+    SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
+  ]);
+  if (isDefined7(dataLakeEndpoint)) {
+    const dataLakeViewerParams = {
+      endpoint: dataLakeEndpoint
+    };
+    locator.register(RestDataLakeViewer2.factory(RestDataLakeViewer2.dependencies, dataLakeViewerParams));
+  }
+  locator.freeze();
+  return locator;
+}
+__name(basicRemoteRunnerLocator, "basicRemoteRunnerLocator");
+
+// src/neutral/config/locators/rootLocatorFromConfig.ts
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
+  const { config } = context;
+  let locator = await commonLocatorFromConfig(context, validateDepsOnRegister);
+  const newLocator = await (config.remote.rpc ? remoteLocatorFromConfig(context, validateDepsOnRegister) : void 0);
+  locator = assertEx9(newLocator, () => "Root locator could not be created from config. No supported configuration found.");
+  locator = await initEvmProvidersIfAvailable(locator);
+  locator.freeze();
+  return locator;
+}
+__name(rootLocatorFromConfig, "rootLocatorFromConfig");
+export {
+  ApiConfigContext,
+  ApiConfigZod,
+  BasisPointsZod,
+  BridgeConfigContext,
+  BridgeConfigZod,
+  BridgeSettingsZod,
+  DefaultServiceProvider,
+  GenericHost,
+  MempoolConfigContext,
+  MempoolConfigZod,
+  Orchestrator,
+  ProducerConfigContext,
+  ProducerConfigZod,
+  RewardRedemptionConfigContext,
+  RewardRedemptionConfigZod,
+  ServiceLifetime,
+  ValidatorActor,
+  asApiConfig,
+  asApiConfigContext,
+  asBridgeConfig,
+  asBridgeConfigContext,
+  asMempoolConfig,
+  asMempoolConfigContext,
+  asProducerConfig,
+  asProducerConfigContext,
+  asRewardRedemptionConfig,
+  asRewardRedemptionConfigContext,
+  basicRemoteRunnerLocator,
+  basicRemoteViewerLocator,
+  buildTelemetryConfig,
+  canUseChainId,
+  canUseEvmProvider,
+  canUseInfuraProvider,
+  canUseJsonRpcProvider,
+  commonLocatorFromConfig,
+  contextFromConfigWithoutLocator,
+  createProducerChainStakeIntentBlock,
+  getChainId,
+  getInfuraProviderConfig,
+  getJsonRpcProviderConfig,
+  initActorAccount,
+  initActorSeedPhrase,
+  initActorWallet,
+  initBridgedArchivistModule,
+  initBridgedModule,
+  initEvmProvider,
+  initEvmProvidersIfAvailable,
+  initInfuraProvider,
+  initJsonRpcProvider,
+  initStatusReporter,
+  isApiConfig,
+  isApiConfigContext,
+  isBridgeConfig,
+  isBridgeConfigContext,
+  isMempoolConfig,
+  isMempoolConfigContext,
+  isProducerConfig,
+  isProducerConfigContext,
+  isRewardRedemptionConfig,
+  isRewardRedemptionConfigContext,
+  mergeConfig,
+  remoteLocatorFromConfig,
+  rootLocatorFromConfig,
+  telemetryContextFromConfig,
+  toApiConfig,
+  toApiConfigContext,
+  toBridgeConfig,
+  toBridgeConfigContext,
+  toMempoolConfig,
+  toMempoolConfigContext,
+  toProducerConfig,
+  toProducerConfigContext,
+  toRewardRedemptionConfig,
+  toRewardRedemptionConfigContext
+};
+//# sourceMappingURL=index.mjs.map