@xyo-network/xl1-cli 1.19.8 → 1.19.10

package/dist/cli-min.mjs

@@ -1,6 +1,3 @@
-import * as nc from 'node:crypto';
-import { randomFillSync, randomUUID } from 'node:crypto';
-import require$$0$c, { createHmac, pbkdf2Sync, randomBytes as randomBytes$3, createHash, subtle, randomFillSync as randomFillSync$1, randomUUID as randomUUID$1 } from 'crypto';
 import require$$0$a, { format as format$4, inspect as inspect$2, debuglog } from 'util';
 import require$$0$e, { cpus } from 'os';
 import require$$0$9, { Readable } from 'stream';
@@ -22,6 +19,7 @@ import require$$1$5 from 'node:events';
 import require$$8 from 'node:path';
 import require$$2$4, { readdirSync as readdirSync$1, readFileSync as readFileSync$1 } from 'node:fs';
 import require$$2$5 from 'node:http';
+import require$$0$c, { createHmac, pbkdf2Sync, randomBytes as randomBytes$3, createHash, subtle, randomFillSync as randomFillSync$1, randomUUID as randomUUID$1 } from 'crypto';
 import require$$6$1 from 'node:querystring';
 import require$$7$1 from 'node:buffer';
 import require$$1$4 from 'node:net';
@@ -30,14 +28,16 @@ import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
 import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
 import require$$1$6, { cwd } from 'process';
 import { Worker as Worker$1 } from 'worker_threads';
-import http2 from 'http2';
-import require$$0$g, { strictEqual, notStrictEqual } from 'assert';
-import { trace as trace$1, context, SpanStatusCode, propagation, ROOT_CONTEXT, ValueType, metrics as metrics$1 } from '@opentelemetry/api';
 import { ConsoleSpanExporter, BatchSpanProcessor, AlwaysOnSampler, BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import process$2 from 'node:process';
 import os from 'node:os';
 import tty from 'node:tty';
 import require$$0$n from 'fs/promises';
+import * as nc from 'node:crypto';
+import { randomFillSync, randomUUID } from 'node:crypto';
+import http2 from 'http2';
+import require$$0$g, { strictEqual, notStrictEqual } from 'assert';
+import { trace as trace$1, context, SpanStatusCode, propagation, ROOT_CONTEXT, ValueType, metrics as metrics$1 } from '@opentelemetry/api';
 import { open } from 'lmdb';
 import require$$0$k from 'timers';
 import require$$0$l from 'timers/promises';
@@ -22029,7 +22029,7 @@ const base64$2 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA
 const base64url$1 = /^[A-Za-z0-9_-]*$/;
 // based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
 // export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
-const hostname$5 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+const hostname$4 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 const domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
 // E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
@@ -22130,7 +22130,7 @@ var regexes$1 = /*#__PURE__*/Object.freeze({
   extendedDuration: extendedDuration,
   guid: guid$1,
   hex: hex$1,
-  hostname: hostname$5,
+  hostname: hostname$4,
   html5Email: html5Email,
   idnEmail: idnEmail,
   integer: integer$1,
@@ -33427,8 +33427,8 @@ const ZodCustomStringFormat = /*@__PURE__*/ $constructor("ZodCustomStringFormat"
 function stringFormat(format, fnOrRegex, _params = {}) {
     return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
-function hostname$4(_params) {
-    return _stringFormat(ZodCustomStringFormat, "hostname", hostname$5, _params);
+function hostname$3(_params) {
+    return _stringFormat(ZodCustomStringFormat, "hostname", hostname$4, _params);
 }
 function hex(_params) {
     return _stringFormat(ZodCustomStringFormat, "hex", hex$1, _params);
@@ -34332,7 +34332,7 @@ var _schemas = /*#__PURE__*/Object.freeze({
   guid: guid,
   hash: hash$1,
   hex: hex,
-  hostname: hostname$4,
+  hostname: hostname$3,
   httpUrl: httpUrl,
   instanceof: _instanceof,
   int: int$1,
@@ -35167,7 +35167,7 @@ var z$1 = /*#__PURE__*/Object.freeze({
   guid: guid,
   hash: hash$1,
   hex: hex,
-  hostname: hostname$4,
+  hostname: hostname$3,
   httpUrl: httpUrl,
   includes: _includes,
   instanceof: _instanceof,
@@ -47824,7 +47824,7 @@ function fromBase36(value) {
  *    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
  *    //_error:
  */
-function getAddress$2(address) {
+function getAddress(address) {
     assertArgument(typeof (address) === "string", "invalid address", "address", address);
     if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
         // Missing the 0x prefix
@@ -47869,7 +47869,7 @@ function getAddress$2(address) {
  *    //_result:
  */
 function getCreateAddress(tx) {
-    const from = getAddress$2(tx.from);
+    const from = getAddress(tx.from);
     const nonce = getBigInt(tx.nonce, "tx.nonce");
     let nonceHex = nonce.toString(16);
     if (nonceHex === "0") {
@@ -47881,7 +47881,7 @@ function getCreateAddress(tx) {
     else {
         nonceHex = "0x" + nonceHex;
     }
-    return getAddress$2(dataSlice(keccak256(encodeRlp([from, nonceHex])), 12));
+    return getAddress(dataSlice(keccak256(encodeRlp([from, nonceHex])), 12));
 }
 
 /**
@@ -47907,7 +47907,7 @@ async function checkAddress(target, promise) {
         assert$1(typeof (target) !== "string", "unconfigured name", "UNCONFIGURED_NAME", { value: target });
         assertArgument(false, "invalid AddressLike value; did not resolve to a value address", "target", target);
     }
-    return getAddress$2(result);
+    return getAddress(result);
 }
 /**
  *  Resolves to an address for the %%target%%, which may be any
@@ -47949,7 +47949,7 @@ async function checkAddress(target, promise) {
 function resolveAddress(target, resolver) {
     if (typeof (target) === "string") {
         if (target.match(/^0x[0-9a-f]{40}$/i)) {
-            return getAddress$2(target);
+            return getAddress(target);
         }
         assert$1(resolver != null, "ENS resolution requires a provider", "UNSUPPORTED_OPERATION", { operation: "resolveName" });
         return checkAddress(target, resolver.resolveName(target));
@@ -48575,7 +48575,7 @@ class AddressCoder extends Coder {
     encode(writer, _value) {
         let value = Typed.dereference(_value, "string");
         try {
-            value = getAddress$2(value);
+            value = getAddress(value);
         }
         catch (error) {
             return this._throwError(error.message, _value);
@@ -48583,7 +48583,7 @@ class AddressCoder extends Coder {
         return writer.writeValue(value);
     }
     decode(reader) {
-        return getAddress$2(toBeHex(reader.readValue(), 20));
+        return getAddress(toBeHex(reader.readValue(), 20));
     }
 }
 
@@ -48984,7 +48984,7 @@ class TupleCoder extends Coder {
 
 function accessSetify(addr, storageKeys) {
     return {
-        address: getAddress$2(addr),
+        address: getAddress(addr),
         storageKeys: storageKeys.map((storageKey, index) => {
             assertArgument(isHexString(storageKey, 32), "invalid slot", `storageKeys[${index}]`, storageKey);
             return storageKey.toLowerCase();
@@ -49019,7 +49019,7 @@ function accessListify(value) {
 
 function authorizationify(auth) {
     return {
-        address: getAddress$2(auth.address),
+        address: getAddress(auth.address),
         nonce: getBigInt((auth.nonce != null) ? auth.nonce : 0),
         chainId: getBigInt((auth.chainId != null) ? auth.chainId : 0),
         signature: Signature.from(auth.signature)
@@ -49039,7 +49039,7 @@ function computeAddress(key) {
     else {
         pubkey = key.publicKey;
     }
-    return getAddress$2(keccak256("0x" + pubkey.substring(4)).substring(26));
+    return getAddress(keccak256("0x" + pubkey.substring(4)).substring(26));
 }
 /**
  *  Returns the recovered address for the private key that was
@@ -49106,7 +49106,7 @@ function handleAddress(value) {
     if (value === "0x") {
         return null;
     }
-    return getAddress$2(value);
+    return getAddress(value);
 }
 function handleAccessList(value, param) {
     try {
@@ -49666,7 +49666,7 @@ class Transaction {
         return value;
     }
     set to(value) {
-        this.#to = (value == null) ? null : getAddress$2(value);
+        this.#to = (value == null) ? null : getAddress(value);
     }
     /**
      *  The transaction nonce.
@@ -50321,7 +50321,7 @@ function hashAuthorization(auth) {
     return keccak256(concat$2([
         "0x05", encodeRlp([
             (auth.chainId != null) ? toBeArray(auth.chainId) : "0x",
-            getAddress$2(auth.address),
+            getAddress(auth.address),
             (auth.nonce != null) ? toBeArray(auth.nonce) : "0x",
         ])
     ]));
@@ -51568,7 +51568,7 @@ const domainChecks = {
     },
     verifyingContract: function (value) {
         try {
-            return getAddress$2(value).toLowerCase();
+            return getAddress(value).toLowerCase();
         }
         catch (error) { }
         assertArgument(false, `invalid domain value "verifyingContract"`, "domain.verifyingContract", value);
@@ -51611,7 +51611,7 @@ function getBaseEncoder(type) {
     }
     switch (type) {
         case "address": return function (value) {
-            return zeroPadValue(getAddress$2(value), 32);
+            return zeroPadValue(getAddress(value), 32);
         };
         case "bool": return function (value) {
             return ((!value) ? hexFalse : hexTrue);
@@ -53431,11 +53431,11 @@ function getBuiltinCallException(action, tx, data, abiCoder) {
         }
     }
     const transaction = {
-        to: (tx.to ? getAddress$2(tx.to) : null),
+        to: (tx.to ? getAddress(tx.to) : null),
         data: (tx.data || "0x")
     };
     if (tx.from) {
-        transaction.from = getAddress$2(tx.from);
+        transaction.from = getAddress(tx.from);
     }
     return makeError(message, "CALL_EXCEPTION", {
         action, data, reason, transaction, invocation, revert
@@ -57357,7 +57357,7 @@ class EnsResolver {
             let ethCoinType = coinType + 0x80000000;
             const data = await this.#fetch("addr(bytes32,uint)", [ethCoinType]);
             if (isHexString(data, 20)) {
-                return getAddress$2(data);
+                return getAddress(data);
             }
         }
         let coinPlugin = null;
@@ -57724,7 +57724,7 @@ function formatHash(value) {
     return value;
 }
 const _formatLog = object$3({
-    address: getAddress$2,
+    address: getAddress,
     blockHash: formatHash,
     blockNumber: getNumber,
     data: formatData,
@@ -57753,7 +57753,7 @@ const _formatBlock = object$3({
     receiptsRoot: allowNull(formatHash, null),
     blobGasUsed: allowNull(getBigInt, null),
     excessBlobGas: allowNull(getBigInt, null),
-    miner: allowNull(getAddress$2),
+    miner: allowNull(getAddress),
     prevRandao: allowNull(formatHash, null),
     extraData: formatData,
     baseFeePerGas: allowNull(getBigInt)
@@ -57774,7 +57774,7 @@ const _formatReceiptLog = object$3({
     transactionIndex: getNumber,
     blockNumber: getNumber,
     transactionHash: formatHash,
-    address: getAddress$2,
+    address: getAddress,
     topics: arrayOf(formatHash),
     data: formatData,
     index: getNumber,
@@ -57786,9 +57786,9 @@ function formatReceiptLog(value) {
     return _formatReceiptLog(value);
 }
 const _formatTransactionReceipt = object$3({
-    to: allowNull(getAddress$2, null),
-    from: allowNull(getAddress$2, null),
-    contractAddress: allowNull(getAddress$2, null),
+    to: allowNull(getAddress, null),
+    from: allowNull(getAddress, null),
+    contractAddress: allowNull(getAddress, null),
     // should be allowNull(hash), but broken-EIP-658 support is handled in receipt
     index: getNumber,
     root: allowNull(hexlify),
@@ -57847,7 +57847,7 @@ function formatTransactionResponse(value) {
                 sig = Object.assign({}, v, { yParity });
             }
             return {
-                address: getAddress$2(v.address),
+                address: getAddress(v.address),
                 chainId: getBigInt(v.chainId),
                 nonce: getBigInt(v.nonce),
                 signature: Signature.from(sig)
@@ -57856,18 +57856,18 @@ function formatTransactionResponse(value) {
         blockHash: allowNull(formatHash, null),
         blockNumber: allowNull(getNumber, null),
         transactionIndex: allowNull(getNumber, null),
-        from: getAddress$2,
+        from: getAddress,
         // either (gasPrice) or (maxPriorityFeePerGas + maxFeePerGas) must be set
         gasPrice: allowNull(getBigInt),
         maxPriorityFeePerGas: allowNull(getBigInt),
         maxFeePerGas: allowNull(getBigInt),
         maxFeePerBlobGas: allowNull(getBigInt, null),
         gasLimit: getBigInt,
-        to: allowNull(getAddress$2, null),
+        to: allowNull(getAddress, null),
         value: getBigInt,
         nonce: getNumber,
         data: formatData,
-        creates: allowNull(getAddress$2, null),
+        creates: allowNull(getAddress, null),
         chainId: allowNull(getBigInt, null)
     }, {
         data: ["input"],
@@ -59593,7 +59593,7 @@ class AbstractProvider {
         return null;
     }
     async lookupAddress(address) {
-        address = getAddress$2(address);
+        address = getAddress(address);
         const node = namehash(address.substring(2).toLowerCase() + ".addr.reverse");
         try {
             const ensAddr = await EnsResolver.getEnsAddress(this);
@@ -60650,7 +60650,7 @@ class JsonRpcSigner extends AbstractSigner {
     address;
     constructor(provider, address) {
         super(provider);
-        address = getAddress$2(address);
+        address = getAddress(address);
         defineProperties(this, { address });
     }
     connect(provider) {
@@ -61385,9 +61385,9 @@ class JsonRpcApiProvider extends AbstractProvider {
             accounts: accountsPromise
         });
         // Account address
-        address = getAddress$2(address);
+        address = getAddress(address);
         for (const account of accounts) {
-            if (getAddress$2(account) === address) {
+            if (getAddress(account) === address) {
                 return new JsonRpcSigner(this, address);
             }
         }
@@ -67312,7 +67312,7 @@ class BaseWallet extends AbstractSigner {
             tx.from = from;
         }
         if (tx.from != null) {
-            assertArgument(getAddress$2((tx.from)) === this.address, "transaction from address mismatch", "tx.from", tx.from);
+            assertArgument(getAddress((tx.from)) === this.address, "transaction from address mismatch", "tx.from", tx.from);
             delete tx.from;
         }
         // Build the transaction
@@ -67338,7 +67338,7 @@ class BaseWallet extends AbstractSigner {
         assertArgument(typeof (auth.address) === "string", "invalid address for authorizeSync", "auth.address", auth);
         const signature = this.signingKey.sign(hashAuthorization(auth));
         return Object.assign({}, {
-            address: getAddress$2(auth.address),
+            address: getAddress(auth.address),
             nonce: getBigInt(auth.nonce || 0),
             chainId: getBigInt(auth.chainId || 0),
         }, { signature });
@@ -68278,7 +68278,7 @@ function getAccount(data, _key) {
         if (!check.startsWith("0x")) {
             check = "0x" + check;
         }
-        assertArgument(getAddress$2(check) === address, "keystore address/privateKey mismatch", "address", data.address);
+        assertArgument(getAddress(check) === address, "keystore address/privateKey mismatch", "address", data.address);
     }
     const account = { address, privateKey };
     // Version 0.1 x-ethers metadata must contain an encrypted mnemonic phrase
@@ -68989,7 +68989,7 @@ function decryptCrowdsaleJson(json, _password) {
     const data = JSON.parse(json);
     const password = getPassword(_password);
     // Ethereum Address
-    const address = getAddress$2(spelunk(data, "ethaddr:string!"));
+    const address = getAddress(spelunk(data, "ethaddr:string!"));
     // Encrypted Seed
     const encseed = looseArrayify(spelunk(data, "encseed:string!"));
     assertArgument(encseed && (encseed.length % 16) === 0, "invalid encseed", "json", json);
@@ -70227,6 +70227,798 @@ Object.defineProperties(createChalk.prototype, styles$2);
 const chalk = createChalk();
 createChalk({level: stderrColor ? stderrColor.level : 0});
 
+// src/isPayload.ts
+var isAnyPayload = (value) => {
+  if (isObject$5(value)) {
+    return typeof value.schema === "string";
+  }
+  return false;
+};
+var asAnyPayload = AsObjectFactory.create(isAnyPayload);
+
+// src/isPayloadOfSchemaType.ts
+function isPayloadOfSchemaType(schema) {
+  return (x) => isAnyPayload(x) && x?.schema === schema;
+}
+var SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/;
+var SchemaZod = z$1.string().regex(SchemaRegEx).transform((v) => v);
+var isSchema = zodIsFactory(SchemaZod);
+var asSchema = zodAsFactory(SchemaZod, "asSchema");
+var PayloadSchema = asSchema("network.xyo.payload", true);
+z$1.literal(PayloadSchema);
+
+// src/Error.ts
+var ModuleErrorSchema = asSchema("network.xyo.error.module", true);
+function isPayloadOfZodType(zodSchema, schema) {
+  return (x) => {
+    if (!isAnyPayload(x)) return false;
+    if (isDefined(schema) && x.schema !== schema) return false;
+    const { schema: _, ...data } = x;
+    return zodSchema.safeParse(data).success;
+  };
+}
+var isLocalSequence = (value) => {
+  return isHex(value) && value.length === SequenceConstants.localSequenceBytes * 2;
+};
+var isQualifiedSequence = (value) => {
+  return isHex(value) && value.length === SequenceConstants.qualifiedSequenceBytes * 2;
+};
+var isSequence = (value) => {
+  return isLocalSequence(value) || isQualifiedSequence(value);
+};
+var SequenceNonceComponentLengths = {
+  nonceIndexBytes: 4,
+  nonceHashBytes: 4
+};
+var SequenceComponentLengths = {
+  ...SequenceNonceComponentLengths,
+  epochBytes: 8,
+  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,
+  addressBytes: 20
+};
+var SequenceComponentMinMax = {
+  minEpoch: "0".repeat(SequenceComponentLengths.epochBytes * 2),
+  maxEpoch: "f".repeat(SequenceComponentLengths.epochBytes * 2),
+  minNonce: "0".repeat(SequenceComponentLengths.nonceBytes * 2),
+  maxNonce: "f".repeat(SequenceComponentLengths.nonceBytes * 2),
+  minAddress: "0".repeat(SequenceComponentLengths.addressBytes * 2),
+  maxAddress: "f".repeat(SequenceComponentLengths.addressBytes * 2)
+};
+var LocalSequenceConstants = {
+  ...SequenceComponentLengths,
+  ...SequenceComponentMinMax,
+  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
+  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce,
+  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce
+};
+var QualifiedSequenceConstants = {
+  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
+  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress,
+  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress
+};
+var SequenceConstants = {
+  ...LocalSequenceConstants,
+  ...QualifiedSequenceConstants
+};
+
+// src/StorageMeta/sequence/Parser.ts
+var SequenceParser = class _SequenceParser {
+  static privateConstructorKey = Date.now().toString();
+  data;
+  constructor(privateConstructorKey, hex) {
+    assertEx(_SequenceParser.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
+    const paddedHex = toHex(hex, {
+      prefix: false,
+      bitLength: hex.length <= SequenceConstants.localSequenceBytes * 2 ? SequenceConstants.localSequenceBytes * 8 : SequenceConstants.qualifiedSequenceBytes * 8
+    });
+    this.data = toUint8Array(paddedHex);
+  }
+  get address() {
+    const start = SequenceConstants.localSequenceBytes;
+    const end = SequenceConstants.qualifiedSequenceBytes;
+    return toAddress(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get epoch() {
+    const start = 0;
+    const end = SequenceConstants.epochBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get localSequence() {
+    const start = 0;
+    const end = SequenceConstants.localSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get nonce() {
+    const start = SequenceConstants.epochBytes;
+    const end = SequenceConstants.localSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get qualifiedSequence() {
+    const start = 0;
+    const end = SequenceConstants.qualifiedSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  static from(timestampOrSequence, nonceOrAddress, addressOrIndex, addressOnly) {
+    const address = typeof addressOrIndex === "number" ? addressOnly : addressOrIndex;
+    const index = typeof addressOrIndex === "number" ? addressOrIndex : void 0;
+    if (isSequence(timestampOrSequence)) {
+      if (nonceOrAddress) {
+        assertEx(!isQualifiedSequence(timestampOrSequence), () => "Providing both a qualified sequence and a address is not allowed");
+        assertEx(isAddress(nonceOrAddress), () => "Invalid address provided");
+        return new this(_SequenceParser.privateConstructorKey, timestampOrSequence + address);
+      }
+      return new this(_SequenceParser.privateConstructorKey, timestampOrSequence);
+    }
+    const epoch = _SequenceParser.toEpoch(timestampOrSequence);
+    const nonce = nonceOrAddress === void 0 ? void 0 : _SequenceParser.toNonce(nonceOrAddress, index);
+    const addressHex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress;
+    const hexString = epoch + nonce + addressHex;
+    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`);
+    return new this(_SequenceParser.privateConstructorKey, hexString);
+  }
+  static parse(value) {
+    const hex = toHex(value);
+    if (isSequence(hex)) {
+      return new this(_SequenceParser.privateConstructorKey, hex);
+    }
+    throw new Error(`Invalid sequence [${value}]`);
+  }
+  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence
+  static toEpoch(value) {
+    assertEx(
+      typeof value !== "number" || Number.isInteger(value),
+      () => "Value must be in integer"
+    );
+    const hex = toHex(value, { prefix: false });
+    if (hex.length <= SequenceConstants.epochBytes * 2) {
+      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 });
+    }
+    if (isSequence(hex)) {
+      return hex.slice(0, SequenceConstants.epochBytes * 2);
+    }
+    throw new Error(`Value could not be converted to epoch [${hex}]`);
+  }
+  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence
+  static toNonce(value, index = 0) {
+    assertEx(
+      typeof value !== "number" || Number.isInteger(value),
+      () => "Value must be in integer"
+    );
+    const hex = toHex(value, { prefix: false });
+    if (isSequence(hex)) {
+      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2);
+    }
+    const hashHex = toHex(hex, { prefix: false, bitLength: SequenceConstants.nonceHashBytes * 8 }).slice(-SequenceConstants.nonceHashBytes * 2);
+    const indexHex = toHex(index, { prefix: false, bitLength: SequenceConstants.nonceIndexBytes * 8 }).slice(-SequenceConstants.nonceIndexBytes * 2);
+    return (indexHex + hashHex).slice(-SequenceConstants.nonceBytes * 2);
+  }
+};
+
+// src/StorageMeta/sequence/Comparer.ts
+var local = (a, b) => {
+  const aa = SequenceParser.from(a);
+  const bb = SequenceParser.from(b);
+  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0;
+};
+var SequenceComparer = { local};
+var LocalSequenceRegex$1 = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
+var LocalSequenceToStringZod$1 = z$1.string().regex(LocalSequenceRegex$1);
+var LocalSequenceFromStringZod$1 = z$1.string().regex(LocalSequenceRegex$1).transform((v) => toHex(v));
+var QualifiedSequenceRegex$1 = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
+var QualifiedSequenceToStringZod$1 = z$1.string().regex(QualifiedSequenceRegex$1);
+var QualifiedSequenceFromStringZod$1 = z$1.string().regex(QualifiedSequenceRegex$1).transform((v) => toHex(v));
+z$1.union([LocalSequenceToStringZod$1, QualifiedSequenceToStringZod$1]);
+var SequenceFromStringZod = z$1.union([LocalSequenceFromStringZod$1, QualifiedSequenceFromStringZod$1]);
+
+// src/PayloadZod.ts
+var HashMetaZod = z$1.object({
+  _hash: HashZod,
+  _dataHash: HashZod
+});
+var isHashMeta = zodIsFactory(HashMetaZod);
+var asHashMeta = zodAsFactory(HashMetaZod, "asHashMeta");
+z$1.object({ _sequence: SequenceFromStringZod });
+var StorageMetaZod = z$1.object({
+  _hash: HashZod,
+  _dataHash: HashZod,
+  _sequence: SequenceFromStringZod
+});
+var isStorageMeta = zodIsFactory(StorageMetaZod);
+var PayloadZod = z$1.object({ schema: SchemaZod });
+PayloadZod.extend(StorageMetaZod.shape);
+var AnyPayloadZod = PayloadZod.loose();
+AnyPayloadZod.extend(StorageMetaZod.shape);
+function WithStorageMetaZod$1(valueZod) {
+  return valueZod.extend(StorageMetaZod.shape);
+}
+function WithHashMetaZod$1(valueZod) {
+  return valueZod.extend(HashMetaZod.shape);
+}
+var PayloadZodStrict = z$1.strictObject({ schema: SchemaZod });
+var PayloadZodLoose = z$1.looseObject({ schema: SchemaZod });
+var PayloadZodOfSchema = (schema) => PayloadZod.extend({ schema: z$1.literal(schema) });
+var PayloadZodStrictOfSchema = (schema) => PayloadZodStrict.extend({ schema: z$1.literal(schema) });
+var PayloadZodLooseOfSchema = (schema) => PayloadZodLoose.extend({ schema: z$1.literal(schema) });
+
+// src/PayloadBundle.ts
+var PayloadBundleSchema = asSchema("network.xyo.payload.bundle", true);
+var PayloadBundleFieldsZod = z$1.object({
+  payloads: PayloadZodLoose.array(),
+  root: HashZod
+});
+var PayloadBundleZod = PayloadZodOfSchema(PayloadBundleSchema).extend(PayloadBundleFieldsZod.shape);
+var isPayloadBundle = zodIsFactory(PayloadBundleZod);
+
+// src/PayloadSet/PayloadSetSchema.ts
+asSchema("network.xyo.payload.set", true);
+
+// src/Config/Config.ts
+var ModuleConfigSchema = asSchema("network.xyo.module.config", true);
+
+// src/CreatableModule/CreatableModule.ts
+function creatableModule() {
+  return (constructor) => {
+  };
+}
+function labeledCreatableModule() {
+  return (constructor) => {
+  };
+}
+var buildModuleFactory = (mod, labels) => {
+  const factory5 = {
+    // Destructure instance properties
+    ...mod,
+    configSchemas: mod.configSchemas,
+    // Copy static methods
+    create: mod.create.bind(mod),
+    defaultConfigSchema: mod.defaultConfigSchema,
+    // Merge module & supplied labels
+    labels: { ...mod.labels, ...labels }
+  };
+  return factory5;
+};
+var registerCreatableModuleFactory = (registry, factory5, labels, primary = false) => {
+  const primarySchemas = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
+  for (const primarySchema of primarySchemas) {
+    if (!factory5.configSchemas.includes(primarySchema)) {
+      console.warn(`Primary schema ${primary} not found in factory configSchemas`);
+    }
+  }
+  const isPrimaryForSchema = (schema) => {
+    switch (typeof primary) {
+      case "boolean": {
+        return primary;
+      }
+      case "string": {
+        return schema === primary;
+      }
+      case "object": {
+        if (Array.isArray(primary)) {
+          return primary.includes(schema);
+        }
+      }
+    }
+    throw new Error(`Invalid primary value: ${primary}`);
+  };
+  const factoryClone = buildModuleFactory(factory5, labels);
+  registry[factory5.defaultConfigSchema] = [factoryClone, ...registry[factoryClone.defaultConfigSchema] ?? []];
+  for (const schema of factoryClone.configSchemas) {
+    registry[schema] = isPrimaryForSchema(schema) ? [factoryClone, ...registry[schema] ?? []] : [...registry[schema] ?? [], factoryClone];
+  }
+};
+var registerCreatableModuleFactories = (factories, registry = {}, primary = false) => {
+  for (const factory5 of factories) {
+    registerCreatableModuleFactory(registry, factory5, void 0, primary);
+  }
+  return registry;
+};
+
+// src/CreatableModule/LabeledCreatableModuleFactory.ts
+var hasLabels$1 = (factory5) => {
+  return factory5.labels !== void 0;
+};
+var ModuleFactory = class _ModuleFactory {
+  configSchemas;
+  creatableModule;
+  defaultConfigSchema;
+  defaultLogger;
+  defaultParams;
+  labels;
+  constructor(creatableModule2, params, labels = {}) {
+    this.creatableModule = creatableModule2;
+    this.defaultParams = params;
+    this.configSchemas = creatableModule2.configSchemas;
+    this.defaultConfigSchema = creatableModule2.defaultConfigSchema;
+    assertEx(this.configSchemas.includes(this.defaultConfigSchema), () => "defaultConfigSchema must be in configSchemas");
+    this.labels = Object.assign({}, creatableModule2.labels ?? {}, labels ?? {});
+  }
+  static withParams(creatableModule2, params, labels = {}) {
+    return new _ModuleFactory(creatableModule2, params, labels);
+  }
+  create(params) {
+    const mergedParams = {
+      ...this.defaultParams,
+      ...params,
+      config: {
+        schema: this.creatableModule.defaultConfigSchema,
+        ...this.defaultParams?.config,
+        ...params?.config
+      }
+    };
+    return this.creatableModule.create(mergedParams);
+  }
+  factory(params, labels = {}) {
+    return new _ModuleFactory(this.creatableModule, params, labels);
+  }
+};
+var ModuleManifestQuerySchema = asSchema("network.xyo.query.module.manifest", true);
+var ModuleAddressQuerySchema = asSchema("network.xyo.query.module.address", true);
+var ModuleStateQuerySchema = asSchema("network.xyo.query.module.state", true);
+var ModuleSubscribeQuerySchema = asSchema("network.xyo.query.module.subscribe", true);
+var requiredModuleShape = {
+  address: "string",
+  queries: "array",
+  query: "function"
+};
+var factory$6 = new IsObjectFactory();
+var isModuleObject = factory$6.create(requiredModuleShape);
+
+// src/module/asModuleObject.ts
+var asModuleObject = AsObjectFactory.create(isModuleObject);
+
+// src/module/IsModuleFactory.ts
+var IsModuleFactory = class {
+  create(expectedQueries, additionalChecks) {
+    const result = (obj, config) => {
+      const mod = asModuleObject(obj);
+      return isModuleObject(mod, config) && (expectedQueries?.reduce((prev, query) => prev && mod.queries.includes(query), true) ?? true) && (additionalChecks?.reduce((prev, check) => prev && check(obj, config), true) ?? true);
+    };
+    return result;
+  }
+};
+
+// src/module/isModule.ts
+var requiredModuleQueries = [ModuleStateQuerySchema];
+var factory2 = new IsModuleFactory();
+var isModule = factory2.create(requiredModuleQueries, [isModuleObject]);
+
+// src/instance/isModuleInstance.ts
+var requiredModuleInstanceFunctions = {
+  manifest: "function",
+  state: "function"
+};
+var factory3 = new IsObjectFactory();
+var isModuleInstance = factory3.create(requiredModuleInstanceFunctions, [isModule]);
+
+// src/instance/asModuleInstance.ts
+var asModuleInstance = AsObjectFactory.create(isModuleInstance);
+var requiredAttachableModuleInstanceFunctions = {
+  downResolver: "object",
+  upResolver: "object"
+};
+var factory4 = new IsObjectFactory();
+var isAttachableModuleInstance = factory4.create(requiredAttachableModuleInstanceFunctions, [
+  isModuleInstance
+]);
+
+// src/instance/attachable/asAttachableInstance.ts
+var asAttachableModuleInstance = AsObjectFactory.create(isAttachableModuleInstance);
+var DeadModuleError = class _DeadModuleError extends Error {
+  error;
+  id;
+  constructor(id, error, msg = "Dead Module Error") {
+    super(`${msg} [${id}]: ${error?.message ?? toSafeJsonString(error)}`);
+    this.id = id;
+    this.error = error;
+    Object.setPrototypeOf(this, _DeadModuleError.prototype);
+  }
+};
+var IsInstanceFactory = class extends IsObjectFactory {
+};
+var ObjectResolverPriority = {
+  VeryLow: 0,
+  Low: 1,
+  Normal: 2,
+  VeryHigh: 4
+};
+
+// src/Labels/Labels.ts
+var hasAllLabels = (source, required) => {
+  if (!required) return true;
+  return Object.entries(required).every(([key, value]) => {
+    return source?.hasOwnProperty(key) && source?.[key] === value;
+  });
+};
+var ModuleLimitationViewLabel = { ModuleLimitationLabelName: "view" };
+
+// src/lib/duplicateModules.ts
+var duplicateModules = (value, index, array) => {
+  return array.findIndex((v) => v.address === value.address) === index;
+};
+
+// src/lib/serializable.ts
+var isSerializable = (value, maxDepth = 10) => {
+  if (maxDepth <= 0) {
+    return false;
+  }
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every((item) => isSerializable(item, maxDepth - 1));
+  }
+  if (typeof value === "object") {
+    if (value instanceof Date || value instanceof RegExp) {
+      return true;
+    }
+    if (value instanceof Set || value instanceof Map) {
+      return false;
+    }
+    if (value !== null && value !== void 0) {
+      return Object.values(value).every((item) => isSerializable(item, maxDepth - 1));
+    }
+  }
+  return false;
+};
+var MODULE_PATH_SEPARATOR = ":";
+var DisallowedModuleIdentifierCharacters = {
+  " ": true,
+  "!": true,
+  '"': true,
+  "#": true,
+  "$": true,
+  "%": true,
+  "&": true,
+  "'": true,
+  "(": true,
+  ")": true,
+  "*": true,
+  ",": true,
+  ".": true,
+  "/": true,
+  ":": true,
+  ";": true,
+  "<": true,
+  "=": true,
+  ">": true,
+  "?": true,
+  "@": true,
+  "[": true,
+  "]": true,
+  "^": true,
+  "_": true,
+  "{": true,
+  "|": true,
+  "}": true,
+  "~": true
+};
+var ReservedModuleIdentifierCharacters = new Set(
+  Object.keys(DisallowedModuleIdentifierCharacters)
+);
+var isModuleName = (value) => {
+  return typeof value === "string" && !isAddress(value) && !includesReservedModuleIdentifierCharacter(value);
+};
+var includesReservedModuleIdentifierCharacter = (value) => {
+  return typeof value === "string" && [...value].some((char) => ReservedModuleIdentifierCharacters.has(char));
+};
+var AddressSchema = asSchema("network.xyo.address", true);
+asSchema("network.xyo.address.child", true);
+var AddressPreviousHashSchema = asSchema("network.xyo.address.hash.previous", true);
+var ModuleDescriptionSchema = asSchema("network.xyo.module.description", true);
+asSchema("network.xyo.module.state", true);
+
+// src/ResolveHelper/resolveAddressToInstance.ts
+var resolveAddressToInstanceDown = async (root, address, includePrivate = void 0, ignore = []) => {
+  if (root.address === address) {
+    return root;
+  }
+  const cache = root.addressCache?.("up", !!includePrivate);
+  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
+  const publicChildren = await root.publicChildren?.() ?? [];
+  const children = [...privateChildren, ...publicChildren];
+  for (const child of children) {
+    const found = await resolveAddressToInstanceDown(child, address, includePrivate, ignore);
+    if (found) {
+      cache?.set(address, new WeakRef(found));
+      return found;
+    }
+  }
+  cache?.set(address, null);
+};
+var resolveAddressToInstanceUp = async (root, address, includePrivate = void 0, ignore = []) => {
+  const cache = root.addressCache?.("up", includePrivate ?? true);
+  const parents = await root.parents?.() ?? [];
+  for (const parent of parents) {
+    const found = await resolveAddressToInstance(parent, address, includePrivate, ignore);
+    if (found) {
+      cache?.set(address, new WeakRef(found));
+      return found;
+    }
+  }
+  cache?.set(address, null);
+};
+var resolveAddressToInstanceAll = async (root, address, includePrivate = void 0, ignore = []) => {
+  const cache = root.addressCache?.("all", !!includePrivate);
+  const result = await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore) ?? await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
+  cache?.set(address, result ? new WeakRef(result) : null);
+  return result;
+};
+var resolveAddressToInstance = async (root, address, includePrivate = void 0, ignore = [], direction = "all") => {
+  switch (direction) {
+    case "all": {
+      return await resolveAddressToInstanceAll(root, address, includePrivate, ignore);
+    }
+    case "up": {
+      return await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
+    }
+    case "down": {
+      return await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore);
+    }
+  }
+};
+
+// src/ResolveHelper/resolveAll.ts
+var resolveAllUp = async (root, maxDepth = 10, exclude = []) => {
+  if (maxDepth === 0) {
+    return [root].filter((mod) => !exclude.includes(mod.address));
+  }
+  const parents = (await root.parents()).filter((mod) => !exclude.includes(mod.address));
+  return (maxDepth > 1 ? [
+    ...(await Promise.all(parents.map(async (mod) => await resolveAllUp(mod, maxDepth - 1, [...exclude, root.address])))).flat(),
+    ...(await Promise.all(parents.map(async (mod) => await resolveAllDown(mod, maxDepth - 1, [...exclude, root.address], true)))).flat(),
+    ...parents,
+    root
+  ] : [...parents, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
+};
+var resolveAllDown = async (root, maxDepth = 10, exclude = [], includePrivate = false) => {
+  if (maxDepth === 0) {
+    return [root];
+  }
+  const children = (await root.publicChildren()).filter((mod) => !exclude.includes(mod.address));
+  const privateChildren = includePrivate ? (await root.privateChildren()).filter((mod) => !exclude.includes(mod.address)) : [];
+  return (maxDepth > 1 ? [
+    ...children,
+    ...(await Promise.all(children.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
+    ...(await Promise.all(privateChildren.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
+    root
+  ] : [...children, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
+};
+var resolveAll = async (root, maxDepth = 10, exclude = []) => {
+  if (maxDepth === 0) {
+    return [root];
+  }
+  return [...await resolveAllUp(root, maxDepth, exclude), ...await resolveAllDown(root, maxDepth, exclude)].filter(duplicateModules);
+};
+
+// src/ResolveHelper/ResolveHelperStatic.ts
+var ResolveHelperStatic = class {
+  static defaultLogger;
+  // eslint-disable-next-line sonarjs/public-static-readonly
+  static transformers = [];
+};
+
+// src/ResolveHelper/resolveLocalNameToInstance.ts
+var resolveLocalNameToInstanceUp = async (root, modName) => {
+  const parents = await root.parents?.() ?? [];
+  return parents.find((parent) => parent.config.name === modName);
+};
+var resolveLocalNameToInstanceDown = async (root, modName, includePrivate = void 0) => {
+  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
+  const publicChildren = await root.publicChildren?.() ?? [];
+  const children = [...privateChildren, ...publicChildren];
+  return children.find((child) => child.config.name === modName);
+};
+var resolveLocalNameToInstanceAll = async (root, modName, includePrivate = false) => {
+  return await resolveLocalNameToInstanceDown(root, modName, includePrivate) ?? await resolveLocalNameToInstanceUp(root, modName);
+};
+var resolveLocalNameToInstance = async (root, modName, includePrivate = false, direction = "all") => {
+  switch (direction) {
+    case "all": {
+      return await resolveLocalNameToInstanceAll(root, modName, includePrivate);
+    }
+    case "up": {
+      return await resolveLocalNameToInstanceUp(root, modName);
+    }
+    case "down": {
+      return await resolveLocalNameToInstanceDown(root, modName, includePrivate);
+    }
+  }
+};
+var resolveLocalNameToAddress = async (root, modName, includePrivate = void 0, direction = "all") => {
+  return (await resolveLocalNameToInstance(root, modName, includePrivate, direction))?.address;
+};
+
+// src/ResolveHelper/transformModuleIdentifier.ts
+var transformModuleIdentifier = async (id, transformers) => {
+  let result = id;
+  for (const transformer of transformers) {
+    result = await transformer.transform(id);
+  }
+  return result;
+};
+
+// src/ResolveHelper/resolvePathToInstance.ts
+var resolvePathToInstance = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
+  const parts = path.split(MODULE_PATH_SEPARATOR);
+  const first = await transformModuleIdentifier(
+    assertEx(parts.shift(), () => `First part is invalid [${path}]`),
+    transformers
+  );
+  if (!first) {
+    return void 0;
+  }
+  const firstAddress = asAddress(first) ?? await resolveLocalNameToAddress(root, first, includePrivate);
+  if (firstAddress) {
+    const firstModule = await resolveAddressToInstance(root, firstAddress, includePrivate);
+    if (firstModule && parts.length > 0) {
+      return resolvePathToInstance(firstModule, parts.join(MODULE_PATH_SEPARATOR));
+    }
+    return firstModule;
+  }
+};
+
+// src/ResolveHelper/resolvePathToAddress.ts
+var resolvePathToAddress = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
+  return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address;
+};
+var traceModuleIdentifier = async (resolver, path) => {
+  const parts = path.split(":");
+  const first = parts.shift();
+  const firstModule = asModuleInstance(
+    assertEx(await resolver.resolve(first, { maxDepth: 1 }), () => `Failed to resolve [${first}]`),
+    () => `Resolved invalid module instance [${first}]`
+  );
+  if (firstModule) {
+    return parts.length > 0 ? [firstModule.address, ...await traceModuleIdentifier(firstModule, parts.join(":"))] : [firstModule.address];
+  }
+  return [];
+};
+
+// src/ResolveHelper/ResolveHelper.ts
+var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
+  static async resolve(config, id = "*", {
+    maxDepth = 3,
+    required = "log",
+    ...options
+  } = {}) {
+    const {
+      transformers,
+      mod,
+      logger = this.defaultLogger,
+      dead = false,
+      upResolver,
+      downResolver,
+      privateResolver
+    } = config;
+    const log = logger ? new IdLogger(logger, () => `ResolveHelper [${mod.id}][${id}]`) : void 0;
+    const downLocalOptions = {
+      ...options,
+      direction: "down",
+      maxDepth,
+      required: false
+    };
+    const upLocalOptions = { ...downLocalOptions, direction: "up" };
+    const childOptions = {
+      ...options,
+      maxDepth: maxDepth - 1,
+      required: false
+    };
+    const direction = options?.direction ?? "all";
+    const up = direction === "up" || direction === "all";
+    const down = direction === "down" || direction === "all";
+    let result;
+    log?.debug("start", id, maxDepth);
+    if (id === "*") {
+      if (dead) {
+        log?.warn("failed [dead]", id);
+        return [];
+      }
+      const modules = [
+        ...down ? await downResolver.resolve("*", downLocalOptions) : [],
+        ...up ? await upResolver.resolve("*", upLocalOptions) : []
+      ].filter(duplicateModules);
+      if (modules.length > 0) {
+        log?.debug("modules [count]", modules.length);
+        log?.debug("modules", toSafeJsonString(modules, 4));
+      }
+      if (maxDepth === 0) {
+        return modules;
+      }
+      const childModules = (await Promise.all(modules.map(async (mod2) => await mod2.resolve("*", childOptions)))).flat().filter(duplicateModules);
+      return [...modules, ...childModules, mod].filter(duplicateModules);
+    } else {
+      switch (typeof id) {
+        case "string": {
+          if (dead) {
+            return void 0;
+          }
+          const resolvedId = assertEx(await resolvePathToAddress(mod, id, false, transformers) ?? id, () => "Invalid resolvedId");
+          const resolvers = [
+            [downResolver, downLocalOptions],
+            [up ? upResolver : void 0, upLocalOptions],
+            [up ? privateResolver : void 0, upLocalOptions]
+          ].filter(([resolver]) => exists$2(resolver));
+          for (const resolver of resolvers) {
+            const [resolverInstance] = resolver;
+            if (!result) {
+              result = await this.resolveModuleIdentifier(resolverInstance, resolvedId);
+            }
+          }
+          break;
+        }
+      }
+    }
+    this.validateRequiredResolve(required, result, id, logger);
+    return result;
+  }
+  // resolves a complex module path to addresses
+  static async resolveModuleIdentifier(resolver, path, required) {
+    const parts = path.split(":");
+    const first = parts.shift();
+    const firstIsAddress = isAddress(first);
+    const resolvedModule = await resolver.resolve(first, { maxDepth: firstIsAddress ? 10 : 1 }) ?? (isString$1(first) ? await resolver.resolvePrivate(first, { maxDepth: firstIsAddress ? 10 : 1 }) : void 0);
+    const finalModule = required ? assertEx(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
+    const firstModule = asModuleInstance(finalModule, () => `Resolved invalid module instance [${first}]`);
+    return isDefined(firstModule) ? parts.length > 0 ? await this.resolveModuleIdentifier(firstModule, parts.join(":")) : firstModule : void 0;
+  }
+  // translates a complex module path to addresses
+  static traceModuleIdentifier(resolver, path) {
+    return traceModuleIdentifier(resolver, path);
+  }
+  static transformModuleIdentifier(identifier, transformers = _ResolveHelper.transformers) {
+    return transformModuleIdentifier(identifier, transformers);
+  }
+  static validateRequiredResolve(required, result, id, logger = this.defaultLogger) {
+    const log = logger ? new IdLogger(logger, () => `validateRequiredResolve [${id}][${result}]`) : void 0;
+    if (isTruthy(required) && (result === void 0 || Array.isArray(result) && result.length > 0)) {
+      switch (required) {
+        case "warn": {
+          log?.warn("resolve failed", id);
+          break;
+        }
+        case "log": {
+          log?.log("resolve failed", id);
+          break;
+        }
+        default: {
+          throw new Error(`resolve failed [${id}]`);
+        }
+      }
+    }
+  }
+};
+
+// src/BoundWitness/BoundWitness.ts
+var BoundWitnessSchema = asSchema("network.xyo.boundwitness", true);
+var SignaturesMetaZod = z$1.object({ $signatures: z$1.array(z$1.union([HexZod, z$1.null()])) });
+var UnsignedSignaturesMetaZod = z$1.object({ $signatures: z$1.array(z$1.null()) });
+var SignedSignaturesMetaZod = z$1.object({ $signatures: z$1.array(HexZod).min(1) });
+
+// src/BoundWitness/BoundWitness.ts
+var BoundWitnessRequiredFieldsZod = z$1.object({
+  addresses: z$1.array(AddressZod),
+  payload_hashes: z$1.array(HashZod),
+  payload_schemas: z$1.array(SchemaZod),
+  previous_hashes: z$1.array(HashZod.nullable())
+});
+var BoundWitnessMetaZod = z$1.object({
+  $destination: AddressZod.optional(),
+  $sourceQuery: HashZod.optional()
+}).extend(SignaturesMetaZod.shape);
+var BoundWitnessZod = PayloadZod.safeExtend({ schema: z$1.literal(BoundWitnessSchema) }).safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape);
+var isBoundWitness = zodIsFactory(BoundWitnessZod);
+var asBoundWitness = zodAsFactory(BoundWitnessZod, "asBoundWitness");
+BoundWitnessZod.loose();
+
+// src/BoundWitness/SignedBoundWitness.ts
+var SignedBoundWitnessZod = BoundWitnessZod.extend(SignedSignaturesMetaZod.shape);
+SignedBoundWitnessZod.loose();
+
+// src/BoundWitness/UnsignedBoundWitness.ts
+var UnsignedBoundWitnessZod = BoundWitnessZod.extend(UnsignedSignaturesMetaZod.shape);
+UnsignedBoundWitnessZod.loose();
+var isQueryBoundWitness = (x) => isBoundWitness(x) && x?.query !== void 0;
+
 // base64 encode/decode derived from: https://github.com/niklasvh/base64-arraybuffer
 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 /* eslint-disable functional/no-expression-statements, functional/immutable-data, @typescript-eslint/no-magic-numbers, no-bitwise, no-plusplus, @typescript-eslint/no-non-null-assertion */
@@ -71578,798 +72370,6 @@ Account = __decorateClass$f([
   staticImplements()
 ], Account);
 
-// src/isPayload.ts
-var isAnyPayload = (value) => {
-  if (isObject$5(value)) {
-    return typeof value.schema === "string";
-  }
-  return false;
-};
-var asAnyPayload = AsObjectFactory.create(isAnyPayload);
-
-// src/isPayloadOfSchemaType.ts
-function isPayloadOfSchemaType(schema) {
-  return (x) => isAnyPayload(x) && x?.schema === schema;
-}
-var SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/;
-var SchemaZod = z$1.string().regex(SchemaRegEx).transform((v) => v);
-var isSchema = zodIsFactory(SchemaZod);
-var asSchema = zodAsFactory(SchemaZod, "asSchema");
-var PayloadSchema = asSchema("network.xyo.payload", true);
-z$1.literal(PayloadSchema);
-
-// src/Error.ts
-var ModuleErrorSchema = asSchema("network.xyo.error.module", true);
-function isPayloadOfZodType(zodSchema, schema) {
-  return (x) => {
-    if (!isAnyPayload(x)) return false;
-    if (isDefined(schema) && x.schema !== schema) return false;
-    const { schema: _, ...data } = x;
-    return zodSchema.safeParse(data).success;
-  };
-}
-var isLocalSequence = (value) => {
-  return isHex(value) && value.length === SequenceConstants.localSequenceBytes * 2;
-};
-var isQualifiedSequence = (value) => {
-  return isHex(value) && value.length === SequenceConstants.qualifiedSequenceBytes * 2;
-};
-var isSequence = (value) => {
-  return isLocalSequence(value) || isQualifiedSequence(value);
-};
-var SequenceNonceComponentLengths = {
-  nonceIndexBytes: 4,
-  nonceHashBytes: 4
-};
-var SequenceComponentLengths = {
-  ...SequenceNonceComponentLengths,
-  epochBytes: 8,
-  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,
-  addressBytes: 20
-};
-var SequenceComponentMinMax = {
-  minEpoch: "0".repeat(SequenceComponentLengths.epochBytes * 2),
-  maxEpoch: "f".repeat(SequenceComponentLengths.epochBytes * 2),
-  minNonce: "0".repeat(SequenceComponentLengths.nonceBytes * 2),
-  maxNonce: "f".repeat(SequenceComponentLengths.nonceBytes * 2),
-  minAddress: "0".repeat(SequenceComponentLengths.addressBytes * 2),
-  maxAddress: "f".repeat(SequenceComponentLengths.addressBytes * 2)
-};
-var LocalSequenceConstants = {
-  ...SequenceComponentLengths,
-  ...SequenceComponentMinMax,
-  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
-  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce,
-  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce
-};
-var QualifiedSequenceConstants = {
-  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
-  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress,
-  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress
-};
-var SequenceConstants = {
-  ...LocalSequenceConstants,
-  ...QualifiedSequenceConstants
-};
-
-// src/StorageMeta/sequence/Parser.ts
-var SequenceParser = class _SequenceParser {
-  static privateConstructorKey = Date.now().toString();
-  data;
-  constructor(privateConstructorKey, hex) {
-    assertEx(_SequenceParser.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
-    const paddedHex = toHex(hex, {
-      prefix: false,
-      bitLength: hex.length <= SequenceConstants.localSequenceBytes * 2 ? SequenceConstants.localSequenceBytes * 8 : SequenceConstants.qualifiedSequenceBytes * 8
-    });
-    this.data = toUint8Array(paddedHex);
-  }
-  get address() {
-    const start = SequenceConstants.localSequenceBytes;
-    const end = SequenceConstants.qualifiedSequenceBytes;
-    return toAddress(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get epoch() {
-    const start = 0;
-    const end = SequenceConstants.epochBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get localSequence() {
-    const start = 0;
-    const end = SequenceConstants.localSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get nonce() {
-    const start = SequenceConstants.epochBytes;
-    const end = SequenceConstants.localSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get qualifiedSequence() {
-    const start = 0;
-    const end = SequenceConstants.qualifiedSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  static from(timestampOrSequence, nonceOrAddress, addressOrIndex, addressOnly) {
-    const address = typeof addressOrIndex === "number" ? addressOnly : addressOrIndex;
-    const index = typeof addressOrIndex === "number" ? addressOrIndex : void 0;
-    if (isSequence(timestampOrSequence)) {
-      if (nonceOrAddress) {
-        assertEx(!isQualifiedSequence(timestampOrSequence), () => "Providing both a qualified sequence and a address is not allowed");
-        assertEx(isAddress(nonceOrAddress), () => "Invalid address provided");
-        return new this(_SequenceParser.privateConstructorKey, timestampOrSequence + address);
-      }
-      return new this(_SequenceParser.privateConstructorKey, timestampOrSequence);
-    }
-    const epoch = _SequenceParser.toEpoch(timestampOrSequence);
-    const nonce = nonceOrAddress === void 0 ? void 0 : _SequenceParser.toNonce(nonceOrAddress, index);
-    const addressHex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress;
-    const hexString = epoch + nonce + addressHex;
-    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`);
-    return new this(_SequenceParser.privateConstructorKey, hexString);
-  }
-  static parse(value) {
-    const hex = toHex(value);
-    if (isSequence(hex)) {
-      return new this(_SequenceParser.privateConstructorKey, hex);
-    }
-    throw new Error(`Invalid sequence [${value}]`);
-  }
-  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence
-  static toEpoch(value) {
-    assertEx(
-      typeof value !== "number" || Number.isInteger(value),
-      () => "Value must be in integer"
-    );
-    const hex = toHex(value, { prefix: false });
-    if (hex.length <= SequenceConstants.epochBytes * 2) {
-      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 });
-    }
-    if (isSequence(hex)) {
-      return hex.slice(0, SequenceConstants.epochBytes * 2);
-    }
-    throw new Error(`Value could not be converted to epoch [${hex}]`);
-  }
-  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence
-  static toNonce(value, index = 0) {
-    assertEx(
-      typeof value !== "number" || Number.isInteger(value),
-      () => "Value must be in integer"
-    );
-    const hex = toHex(value, { prefix: false });
-    if (isSequence(hex)) {
-      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2);
-    }
-    const hashHex = toHex(hex, { prefix: false, bitLength: SequenceConstants.nonceHashBytes * 8 }).slice(-SequenceConstants.nonceHashBytes * 2);
-    const indexHex = toHex(index, { prefix: false, bitLength: SequenceConstants.nonceIndexBytes * 8 }).slice(-SequenceConstants.nonceIndexBytes * 2);
-    return (indexHex + hashHex).slice(-SequenceConstants.nonceBytes * 2);
-  }
-};
-
-// src/StorageMeta/sequence/Comparer.ts
-var local = (a, b) => {
-  const aa = SequenceParser.from(a);
-  const bb = SequenceParser.from(b);
-  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0;
-};
-var SequenceComparer = { local};
-var LocalSequenceRegex$1 = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod$1 = z$1.string().regex(LocalSequenceRegex$1);
-var LocalSequenceFromStringZod$1 = z$1.string().regex(LocalSequenceRegex$1).transform((v) => toHex(v));
-var QualifiedSequenceRegex$1 = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod$1 = z$1.string().regex(QualifiedSequenceRegex$1);
-var QualifiedSequenceFromStringZod$1 = z$1.string().regex(QualifiedSequenceRegex$1).transform((v) => toHex(v));
-z$1.union([LocalSequenceToStringZod$1, QualifiedSequenceToStringZod$1]);
-var SequenceFromStringZod = z$1.union([LocalSequenceFromStringZod$1, QualifiedSequenceFromStringZod$1]);
-
-// src/PayloadZod.ts
-var HashMetaZod = z$1.object({
-  _hash: HashZod,
-  _dataHash: HashZod
-});
-var isHashMeta = zodIsFactory(HashMetaZod);
-var asHashMeta = zodAsFactory(HashMetaZod, "asHashMeta");
-z$1.object({ _sequence: SequenceFromStringZod });
-var StorageMetaZod = z$1.object({
-  _hash: HashZod,
-  _dataHash: HashZod,
-  _sequence: SequenceFromStringZod
-});
-var isStorageMeta = zodIsFactory(StorageMetaZod);
-var PayloadZod = z$1.object({ schema: SchemaZod });
-PayloadZod.extend(StorageMetaZod.shape);
-var AnyPayloadZod = PayloadZod.loose();
-AnyPayloadZod.extend(StorageMetaZod.shape);
-function WithStorageMetaZod$1(valueZod) {
-  return valueZod.extend(StorageMetaZod.shape);
-}
-function WithHashMetaZod$1(valueZod) {
-  return valueZod.extend(HashMetaZod.shape);
-}
-var PayloadZodStrict = z$1.strictObject({ schema: SchemaZod });
-var PayloadZodLoose = z$1.looseObject({ schema: SchemaZod });
-var PayloadZodOfSchema = (schema) => PayloadZod.extend({ schema: z$1.literal(schema) });
-var PayloadZodStrictOfSchema = (schema) => PayloadZodStrict.extend({ schema: z$1.literal(schema) });
-var PayloadZodLooseOfSchema = (schema) => PayloadZodLoose.extend({ schema: z$1.literal(schema) });
-
-// src/PayloadBundle.ts
-var PayloadBundleSchema = asSchema("network.xyo.payload.bundle", true);
-var PayloadBundleFieldsZod = z$1.object({
-  payloads: PayloadZodLoose.array(),
-  root: HashZod
-});
-var PayloadBundleZod = PayloadZodOfSchema(PayloadBundleSchema).extend(PayloadBundleFieldsZod.shape);
-var isPayloadBundle = zodIsFactory(PayloadBundleZod);
-
-// src/PayloadSet/PayloadSetSchema.ts
-asSchema("network.xyo.payload.set", true);
-
-// src/Config/Config.ts
-var ModuleConfigSchema = asSchema("network.xyo.module.config", true);
-
-// src/CreatableModule/CreatableModule.ts
-function creatableModule() {
-  return (constructor) => {
-  };
-}
-function labeledCreatableModule() {
-  return (constructor) => {
-  };
-}
-var buildModuleFactory = (mod, labels) => {
-  const factory5 = {
-    // Destructure instance properties
-    ...mod,
-    configSchemas: mod.configSchemas,
-    // Copy static methods
-    create: mod.create.bind(mod),
-    defaultConfigSchema: mod.defaultConfigSchema,
-    // Merge module & supplied labels
-    labels: { ...mod.labels, ...labels }
-  };
-  return factory5;
-};
-var registerCreatableModuleFactory = (registry, factory5, labels, primary = false) => {
-  const primarySchemas = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
-  for (const primarySchema of primarySchemas) {
-    if (!factory5.configSchemas.includes(primarySchema)) {
-      console.warn(`Primary schema ${primary} not found in factory configSchemas`);
-    }
-  }
-  const isPrimaryForSchema = (schema) => {
-    switch (typeof primary) {
-      case "boolean": {
-        return primary;
-      }
-      case "string": {
-        return schema === primary;
-      }
-      case "object": {
-        if (Array.isArray(primary)) {
-          return primary.includes(schema);
-        }
-      }
-    }
-    throw new Error(`Invalid primary value: ${primary}`);
-  };
-  const factoryClone = buildModuleFactory(factory5, labels);
-  registry[factory5.defaultConfigSchema] = [factoryClone, ...registry[factoryClone.defaultConfigSchema] ?? []];
-  for (const schema of factoryClone.configSchemas) {
-    registry[schema] = isPrimaryForSchema(schema) ? [factoryClone, ...registry[schema] ?? []] : [...registry[schema] ?? [], factoryClone];
-  }
-};
-var registerCreatableModuleFactories = (factories, registry = {}, primary = false) => {
-  for (const factory5 of factories) {
-    registerCreatableModuleFactory(registry, factory5, void 0, primary);
-  }
-  return registry;
-};
-
-// src/CreatableModule/LabeledCreatableModuleFactory.ts
-var hasLabels$1 = (factory5) => {
-  return factory5.labels !== void 0;
-};
-var ModuleFactory = class _ModuleFactory {
-  configSchemas;
-  creatableModule;
-  defaultConfigSchema;
-  defaultLogger;
-  defaultParams;
-  labels;
-  constructor(creatableModule2, params, labels = {}) {
-    this.creatableModule = creatableModule2;
-    this.defaultParams = params;
-    this.configSchemas = creatableModule2.configSchemas;
-    this.defaultConfigSchema = creatableModule2.defaultConfigSchema;
-    assertEx(this.configSchemas.includes(this.defaultConfigSchema), () => "defaultConfigSchema must be in configSchemas");
-    this.labels = Object.assign({}, creatableModule2.labels ?? {}, labels ?? {});
-  }
-  static withParams(creatableModule2, params, labels = {}) {
-    return new _ModuleFactory(creatableModule2, params, labels);
-  }
-  create(params) {
-    const mergedParams = {
-      ...this.defaultParams,
-      ...params,
-      config: {
-        schema: this.creatableModule.defaultConfigSchema,
-        ...this.defaultParams?.config,
-        ...params?.config
-      }
-    };
-    return this.creatableModule.create(mergedParams);
-  }
-  factory(params, labels = {}) {
-    return new _ModuleFactory(this.creatableModule, params, labels);
-  }
-};
-var ModuleManifestQuerySchema = asSchema("network.xyo.query.module.manifest", true);
-var ModuleAddressQuerySchema = asSchema("network.xyo.query.module.address", true);
-var ModuleStateQuerySchema = asSchema("network.xyo.query.module.state", true);
-var ModuleSubscribeQuerySchema = asSchema("network.xyo.query.module.subscribe", true);
-var requiredModuleShape = {
-  address: "string",
-  queries: "array",
-  query: "function"
-};
-var factory$6 = new IsObjectFactory();
-var isModuleObject = factory$6.create(requiredModuleShape);
-
-// src/module/asModuleObject.ts
-var asModuleObject = AsObjectFactory.create(isModuleObject);
-
-// src/module/IsModuleFactory.ts
-var IsModuleFactory = class {
-  create(expectedQueries, additionalChecks) {
-    const result = (obj, config) => {
-      const mod = asModuleObject(obj);
-      return isModuleObject(mod, config) && (expectedQueries?.reduce((prev, query) => prev && mod.queries.includes(query), true) ?? true) && (additionalChecks?.reduce((prev, check) => prev && check(obj, config), true) ?? true);
-    };
-    return result;
-  }
-};
-
-// src/module/isModule.ts
-var requiredModuleQueries = [ModuleStateQuerySchema];
-var factory2 = new IsModuleFactory();
-var isModule = factory2.create(requiredModuleQueries, [isModuleObject]);
-
-// src/instance/isModuleInstance.ts
-var requiredModuleInstanceFunctions = {
-  manifest: "function",
-  state: "function"
-};
-var factory3 = new IsObjectFactory();
-var isModuleInstance = factory3.create(requiredModuleInstanceFunctions, [isModule]);
-
-// src/instance/asModuleInstance.ts
-var asModuleInstance = AsObjectFactory.create(isModuleInstance);
-var requiredAttachableModuleInstanceFunctions = {
-  downResolver: "object",
-  upResolver: "object"
-};
-var factory4 = new IsObjectFactory();
-var isAttachableModuleInstance = factory4.create(requiredAttachableModuleInstanceFunctions, [
-  isModuleInstance
-]);
-
-// src/instance/attachable/asAttachableInstance.ts
-var asAttachableModuleInstance = AsObjectFactory.create(isAttachableModuleInstance);
-var DeadModuleError = class _DeadModuleError extends Error {
-  error;
-  id;
-  constructor(id, error, msg = "Dead Module Error") {
-    super(`${msg} [${id}]: ${error?.message ?? toSafeJsonString(error)}`);
-    this.id = id;
-    this.error = error;
-    Object.setPrototypeOf(this, _DeadModuleError.prototype);
-  }
-};
-var IsInstanceFactory = class extends IsObjectFactory {
-};
-var ObjectResolverPriority = {
-  VeryLow: 0,
-  Low: 1,
-  Normal: 2,
-  VeryHigh: 4
-};
-
-// src/Labels/Labels.ts
-var hasAllLabels = (source, required) => {
-  if (!required) return true;
-  return Object.entries(required).every(([key, value]) => {
-    return source?.hasOwnProperty(key) && source?.[key] === value;
-  });
-};
-var ModuleLimitationViewLabel = { ModuleLimitationLabelName: "view" };
-
-// src/lib/duplicateModules.ts
-var duplicateModules = (value, index, array) => {
-  return array.findIndex((v) => v.address === value.address) === index;
-};
-
-// src/lib/serializable.ts
-var isSerializable = (value, maxDepth = 10) => {
-  if (maxDepth <= 0) {
-    return false;
-  }
-  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-    return true;
-  }
-  if (Array.isArray(value)) {
-    return value.every((item) => isSerializable(item, maxDepth - 1));
-  }
-  if (typeof value === "object") {
-    if (value instanceof Date || value instanceof RegExp) {
-      return true;
-    }
-    if (value instanceof Set || value instanceof Map) {
-      return false;
-    }
-    if (value !== null && value !== void 0) {
-      return Object.values(value).every((item) => isSerializable(item, maxDepth - 1));
-    }
-  }
-  return false;
-};
-var MODULE_PATH_SEPARATOR = ":";
-var DisallowedModuleIdentifierCharacters = {
-  " ": true,
-  "!": true,
-  '"': true,
-  "#": true,
-  "$": true,
-  "%": true,
-  "&": true,
-  "'": true,
-  "(": true,
-  ")": true,
-  "*": true,
-  ",": true,
-  ".": true,
-  "/": true,
-  ":": true,
-  ";": true,
-  "<": true,
-  "=": true,
-  ">": true,
-  "?": true,
-  "@": true,
-  "[": true,
-  "]": true,
-  "^": true,
-  "_": true,
-  "{": true,
-  "|": true,
-  "}": true,
-  "~": true
-};
-var ReservedModuleIdentifierCharacters = new Set(
-  Object.keys(DisallowedModuleIdentifierCharacters)
-);
-var isModuleName = (value) => {
-  return typeof value === "string" && !isAddress(value) && !includesReservedModuleIdentifierCharacter(value);
-};
-var includesReservedModuleIdentifierCharacter = (value) => {
-  return typeof value === "string" && [...value].some((char) => ReservedModuleIdentifierCharacters.has(char));
-};
-var AddressSchema = asSchema("network.xyo.address", true);
-asSchema("network.xyo.address.child", true);
-var AddressPreviousHashSchema = asSchema("network.xyo.address.hash.previous", true);
-var ModuleDescriptionSchema = asSchema("network.xyo.module.description", true);
-asSchema("network.xyo.module.state", true);
-
-// src/ResolveHelper/resolveAddressToInstance.ts
-var resolveAddressToInstanceDown = async (root, address, includePrivate = void 0, ignore = []) => {
-  if (root.address === address) {
-    return root;
-  }
-  const cache = root.addressCache?.("up", !!includePrivate);
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
-  const publicChildren = await root.publicChildren?.() ?? [];
-  const children = [...privateChildren, ...publicChildren];
-  for (const child of children) {
-    const found = await resolveAddressToInstanceDown(child, address, includePrivate, ignore);
-    if (found) {
-      cache?.set(address, new WeakRef(found));
-      return found;
-    }
-  }
-  cache?.set(address, null);
-};
-var resolveAddressToInstanceUp = async (root, address, includePrivate = void 0, ignore = []) => {
-  const cache = root.addressCache?.("up", includePrivate ?? true);
-  const parents = await root.parents?.() ?? [];
-  for (const parent of parents) {
-    const found = await resolveAddressToInstance(parent, address, includePrivate, ignore);
-    if (found) {
-      cache?.set(address, new WeakRef(found));
-      return found;
-    }
-  }
-  cache?.set(address, null);
-};
-var resolveAddressToInstanceAll = async (root, address, includePrivate = void 0, ignore = []) => {
-  const cache = root.addressCache?.("all", !!includePrivate);
-  const result = await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore) ?? await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
-  cache?.set(address, result ? new WeakRef(result) : null);
-  return result;
-};
-var resolveAddressToInstance = async (root, address, includePrivate = void 0, ignore = [], direction = "all") => {
-  switch (direction) {
-    case "all": {
-      return await resolveAddressToInstanceAll(root, address, includePrivate, ignore);
-    }
-    case "up": {
-      return await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
-    }
-    case "down": {
-      return await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore);
-    }
-  }
-};
-
-// src/ResolveHelper/resolveAll.ts
-var resolveAllUp = async (root, maxDepth = 10, exclude = []) => {
-  if (maxDepth === 0) {
-    return [root].filter((mod) => !exclude.includes(mod.address));
-  }
-  const parents = (await root.parents()).filter((mod) => !exclude.includes(mod.address));
-  return (maxDepth > 1 ? [
-    ...(await Promise.all(parents.map(async (mod) => await resolveAllUp(mod, maxDepth - 1, [...exclude, root.address])))).flat(),
-    ...(await Promise.all(parents.map(async (mod) => await resolveAllDown(mod, maxDepth - 1, [...exclude, root.address], true)))).flat(),
-    ...parents,
-    root
-  ] : [...parents, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
-};
-var resolveAllDown = async (root, maxDepth = 10, exclude = [], includePrivate = false) => {
-  if (maxDepth === 0) {
-    return [root];
-  }
-  const children = (await root.publicChildren()).filter((mod) => !exclude.includes(mod.address));
-  const privateChildren = includePrivate ? (await root.privateChildren()).filter((mod) => !exclude.includes(mod.address)) : [];
-  return (maxDepth > 1 ? [
-    ...children,
-    ...(await Promise.all(children.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
-    ...(await Promise.all(privateChildren.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
-    root
-  ] : [...children, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
-};
-var resolveAll = async (root, maxDepth = 10, exclude = []) => {
-  if (maxDepth === 0) {
-    return [root];
-  }
-  return [...await resolveAllUp(root, maxDepth, exclude), ...await resolveAllDown(root, maxDepth, exclude)].filter(duplicateModules);
-};
-
-// src/ResolveHelper/ResolveHelperStatic.ts
-var ResolveHelperStatic = class {
-  static defaultLogger;
-  // eslint-disable-next-line sonarjs/public-static-readonly
-  static transformers = [];
-};
-
-// src/ResolveHelper/resolveLocalNameToInstance.ts
-var resolveLocalNameToInstanceUp = async (root, modName) => {
-  const parents = await root.parents?.() ?? [];
-  return parents.find((parent) => parent.config.name === modName);
-};
-var resolveLocalNameToInstanceDown = async (root, modName, includePrivate = void 0) => {
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
-  const publicChildren = await root.publicChildren?.() ?? [];
-  const children = [...privateChildren, ...publicChildren];
-  return children.find((child) => child.config.name === modName);
-};
-var resolveLocalNameToInstanceAll = async (root, modName, includePrivate = false) => {
-  return await resolveLocalNameToInstanceDown(root, modName, includePrivate) ?? await resolveLocalNameToInstanceUp(root, modName);
-};
-var resolveLocalNameToInstance = async (root, modName, includePrivate = false, direction = "all") => {
-  switch (direction) {
-    case "all": {
-      return await resolveLocalNameToInstanceAll(root, modName, includePrivate);
-    }
-    case "up": {
-      return await resolveLocalNameToInstanceUp(root, modName);
-    }
-    case "down": {
-      return await resolveLocalNameToInstanceDown(root, modName, includePrivate);
-    }
-  }
-};
-var resolveLocalNameToAddress = async (root, modName, includePrivate = void 0, direction = "all") => {
-  return (await resolveLocalNameToInstance(root, modName, includePrivate, direction))?.address;
-};
-
-// src/ResolveHelper/transformModuleIdentifier.ts
-var transformModuleIdentifier = async (id, transformers) => {
-  let result = id;
-  for (const transformer of transformers) {
-    result = await transformer.transform(id);
-  }
-  return result;
-};
-
-// src/ResolveHelper/resolvePathToInstance.ts
-var resolvePathToInstance = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
-  const parts = path.split(MODULE_PATH_SEPARATOR);
-  const first = await transformModuleIdentifier(
-    assertEx(parts.shift(), () => `First part is invalid [${path}]`),
-    transformers
-  );
-  if (!first) {
-    return void 0;
-  }
-  const firstAddress = asAddress(first) ?? await resolveLocalNameToAddress(root, first, includePrivate);
-  if (firstAddress) {
-    const firstModule = await resolveAddressToInstance(root, firstAddress, includePrivate);
-    if (firstModule && parts.length > 0) {
-      return resolvePathToInstance(firstModule, parts.join(MODULE_PATH_SEPARATOR));
-    }
-    return firstModule;
-  }
-};
-
-// src/ResolveHelper/resolvePathToAddress.ts
-var resolvePathToAddress = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
-  return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address;
-};
-var traceModuleIdentifier = async (resolver, path) => {
-  const parts = path.split(":");
-  const first = parts.shift();
-  const firstModule = asModuleInstance(
-    assertEx(await resolver.resolve(first, { maxDepth: 1 }), () => `Failed to resolve [${first}]`),
-    () => `Resolved invalid module instance [${first}]`
-  );
-  if (firstModule) {
-    return parts.length > 0 ? [firstModule.address, ...await traceModuleIdentifier(firstModule, parts.join(":"))] : [firstModule.address];
-  }
-  return [];
-};
-
-// src/ResolveHelper/ResolveHelper.ts
-var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
-  static async resolve(config, id = "*", {
-    maxDepth = 3,
-    required = "log",
-    ...options
-  } = {}) {
-    const {
-      transformers,
-      mod,
-      logger = this.defaultLogger,
-      dead = false,
-      upResolver,
-      downResolver,
-      privateResolver
-    } = config;
-    const log = logger ? new IdLogger(logger, () => `ResolveHelper [${mod.id}][${id}]`) : void 0;
-    const downLocalOptions = {
-      ...options,
-      direction: "down",
-      maxDepth,
-      required: false
-    };
-    const upLocalOptions = { ...downLocalOptions, direction: "up" };
-    const childOptions = {
-      ...options,
-      maxDepth: maxDepth - 1,
-      required: false
-    };
-    const direction = options?.direction ?? "all";
-    const up = direction === "up" || direction === "all";
-    const down = direction === "down" || direction === "all";
-    let result;
-    log?.debug("start", id, maxDepth);
-    if (id === "*") {
-      if (dead) {
-        log?.warn("failed [dead]", id);
-        return [];
-      }
-      const modules = [
-        ...down ? await downResolver.resolve("*", downLocalOptions) : [],
-        ...up ? await upResolver.resolve("*", upLocalOptions) : []
-      ].filter(duplicateModules);
-      if (modules.length > 0) {
-        log?.debug("modules [count]", modules.length);
-        log?.debug("modules", toSafeJsonString(modules, 4));
-      }
-      if (maxDepth === 0) {
-        return modules;
-      }
-      const childModules = (await Promise.all(modules.map(async (mod2) => await mod2.resolve("*", childOptions)))).flat().filter(duplicateModules);
-      return [...modules, ...childModules, mod].filter(duplicateModules);
-    } else {
-      switch (typeof id) {
-        case "string": {
-          if (dead) {
-            return void 0;
-          }
-          const resolvedId = assertEx(await resolvePathToAddress(mod, id, false, transformers) ?? id, () => "Invalid resolvedId");
-          const resolvers = [
-            [downResolver, downLocalOptions],
-            [up ? upResolver : void 0, upLocalOptions],
-            [up ? privateResolver : void 0, upLocalOptions]
-          ].filter(([resolver]) => exists$2(resolver));
-          for (const resolver of resolvers) {
-            const [resolverInstance] = resolver;
-            if (!result) {
-              result = await this.resolveModuleIdentifier(resolverInstance, resolvedId);
-            }
-          }
-          break;
-        }
-      }
-    }
-    this.validateRequiredResolve(required, result, id, logger);
-    return result;
-  }
-  // resolves a complex module path to addresses
-  static async resolveModuleIdentifier(resolver, path, required) {
-    const parts = path.split(":");
-    const first = parts.shift();
-    const firstIsAddress = isAddress(first);
-    const resolvedModule = await resolver.resolve(first, { maxDepth: firstIsAddress ? 10 : 1 }) ?? (isString$1(first) ? await resolver.resolvePrivate(first, { maxDepth: firstIsAddress ? 10 : 1 }) : void 0);
-    const finalModule = required ? assertEx(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
-    const firstModule = asModuleInstance(finalModule, () => `Resolved invalid module instance [${first}]`);
-    return isDefined(firstModule) ? parts.length > 0 ? await this.resolveModuleIdentifier(firstModule, parts.join(":")) : firstModule : void 0;
-  }
-  // translates a complex module path to addresses
-  static traceModuleIdentifier(resolver, path) {
-    return traceModuleIdentifier(resolver, path);
-  }
-  static transformModuleIdentifier(identifier, transformers = _ResolveHelper.transformers) {
-    return transformModuleIdentifier(identifier, transformers);
-  }
-  static validateRequiredResolve(required, result, id, logger = this.defaultLogger) {
-    const log = logger ? new IdLogger(logger, () => `validateRequiredResolve [${id}][${result}]`) : void 0;
-    if (isTruthy(required) && (result === void 0 || Array.isArray(result) && result.length > 0)) {
-      switch (required) {
-        case "warn": {
-          log?.warn("resolve failed", id);
-          break;
-        }
-        case "log": {
-          log?.log("resolve failed", id);
-          break;
-        }
-        default: {
-          throw new Error(`resolve failed [${id}]`);
-        }
-      }
-    }
-  }
-};
-
-// src/BoundWitness/BoundWitness.ts
-var BoundWitnessSchema = asSchema("network.xyo.boundwitness", true);
-var SignaturesMetaZod = z$1.object({ $signatures: z$1.array(z$1.union([HexZod, z$1.null()])) });
-var UnsignedSignaturesMetaZod = z$1.object({ $signatures: z$1.array(z$1.null()) });
-var SignedSignaturesMetaZod = z$1.object({ $signatures: z$1.array(HexZod).min(1) });
-
-// src/BoundWitness/BoundWitness.ts
-var BoundWitnessRequiredFieldsZod = z$1.object({
-  addresses: z$1.array(AddressZod),
-  payload_hashes: z$1.array(HashZod),
-  payload_schemas: z$1.array(SchemaZod),
-  previous_hashes: z$1.array(HashZod.nullable())
-});
-var BoundWitnessMetaZod = z$1.object({
-  $destination: AddressZod.optional(),
-  $sourceQuery: HashZod.optional()
-}).extend(SignaturesMetaZod.shape);
-var BoundWitnessZod = PayloadZod.safeExtend({ schema: z$1.literal(BoundWitnessSchema) }).safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape);
-var isBoundWitness = zodIsFactory(BoundWitnessZod);
-var asBoundWitness = zodAsFactory(BoundWitnessZod, "asBoundWitness");
-BoundWitnessZod.loose();
-
-// src/BoundWitness/SignedBoundWitness.ts
-var SignedBoundWitnessZod = BoundWitnessZod.extend(SignedSignaturesMetaZod.shape);
-SignedBoundWitnessZod.loose();
-
-// src/BoundWitness/UnsignedBoundWitness.ts
-var UnsignedBoundWitnessZod = BoundWitnessZod.extend(UnsignedSignaturesMetaZod.shape);
-UnsignedBoundWitnessZod.loose();
-var isQueryBoundWitness = (x) => isBoundWitness(x) && x?.query !== void 0;
-
 var srcExports = requireSrc$1();
 var debug$3 = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
 
@@ -84255,6 +84255,7 @@ var SignedHydratedTransactionZod = tuple([
   SignedTransactionBoundWitnessZod,
   array$1(PayloadZodLoose)
 ]);
+var isSignedHydratedTransaction = zodIsFactory(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var SignedHydratedTransactionWithHashMetaZod = tuple([
   WithHashMetaZod$1(SignedTransactionBoundWitnessZod),
@@ -84603,9 +84604,6 @@ var StorageConfigZod = object$4({
     type: "string"
   })
 }).describe("Storage configuration options");
-var DefaultMetricsScrapePorts = {
-  api: 9465,
-  mempool: 9466};
 var MetricsScrapeConfigZod = object$4({
   path: string$2().default("/metrics").register(globalRegistry, {
     default: "/metrics",
@@ -84961,7 +84959,6 @@ var ActorsConfigZod = object$4({
   rewardRedemption: RewardRedemptionConfigZod.parse({})
 });
 var ConfigZod = BaseConfigZod.extend(object$4({ actors: ActorsConfigZod.default(ActorsConfigZod.parse({})) }).describe("Actor-specific configurations that override the base configuration when the actor is running").shape);
-var getDefaultConfig = () => ConfigZod.parse({});
 var DescriptionSchema = string$2();
 var TitleSchema = string$2();
 var JSONSchemaMetaSchema = object$4({
@@ -85357,7 +85354,7 @@ var Actor = class extends AbstractCreatable {
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   static initContext(params) {
     const logger = params?.context?.logger;
-    const config = params?.context?.config ?? getDefaultConfig();
+    const config = params?.context?.config ?? ConfigZod.parse({});
     const singletons = params?.context?.singletons ?? {};
     const locator = params.context?.locator ?? new ProviderFactoryLocator({
       ...params?.context,
@@ -87804,11 +87801,17 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     const connection = this.connection;
     const signer = this.signer;
     const runner = assertEx(connection.runner, () => "No runner available on connection");
-    const signedTx = await signer.signTransaction(tx);
+    let signedTx;
+    if (isSignedHydratedTransaction(tx)) {
+      const [bw, payloads] = tx;
+      const hashedBw = await PayloadBuilder.addHashMeta(bw);
+      const hashedPayloads = await PayloadBuilder.addHashMeta(payloads);
+      signedTx = [hashedBw, hashedPayloads];
+    } else {
+      signedTx = await signer.signTransaction(tx);
+    }
     await this.addPayloadsToDataLakes([...signedTx[1], ...offChain ?? [], signedTx[0]]);
-    return [await runner.broadcastTransaction(
-      [signedTx[0], signedTx[1]]
-    ), signedTx];
+    return [await runner.broadcastTransaction([signedTx[0], signedTx[1]]), signedTx];
   }
   async confirmSubmittedTransaction(txHash, options) {
     return await confirmSubmittedTransaction(
@@ -92216,6 +92219,18 @@ var createRequestSchema = (methodName, paramsSchema = _undefined()) => object$4(
   method: literal$2(methodName),
   params: paramsSchema
 });
+var FinalizationViewerRpcSchemas = {
+  finalizationViewer_head: {
+    params: {
+      to: array$1(any$1()).length(0).optional(),
+      from: array$1(any$1()).length(0).optional()
+    },
+    result: {
+      to: SignedHydratedBlockWithHashMetaZod,
+      from: SignedHydratedBlockWithHashMetaZod
+    }
+  }
+};
 
 // src/engine-node/rpcEngineFromConnection.ts
 var rpcEngineFromConnection = (connection) => {
@@ -92449,6 +92464,38 @@ __publicField$3(JsonRpcBlockViewer, "monikers", [BlockViewerMoniker]);
 JsonRpcBlockViewer = __decorateClass$3([
   creatableProvider()
 ], JsonRpcBlockViewer);
+var JsonRpcFinalizationViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = FinalizationViewerMoniker;
+  async head() {
+    const result = await this.transport.sendRequest(
+      "finalizationViewer_head",
+      []
+    );
+    return result;
+  }
+  schemas() {
+    return FinalizationViewerRpcSchemas;
+  }
+};
+
+// src/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewer.ts
+var JsonRpcFinalizationViewer = class extends JsonRpcFinalizationViewerMethods {
+  async headBlock() {
+    return (await this.head())[0];
+  }
+  async headHash() {
+    return (await this.head())[0]._hash;
+  }
+  async headNumber() {
+    return (await this.head())[0].block;
+  }
+};
+__publicField$3(JsonRpcFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker);
+__publicField$3(JsonRpcFinalizationViewer, "dependencies", []);
+__publicField$3(JsonRpcFinalizationViewer, "monikers", [FinalizationViewerMoniker]);
+JsonRpcFinalizationViewer = __decorateClass$3([
+  creatableProvider()
+], JsonRpcFinalizationViewer);
 var JsonRpcMempoolViewerMethods = class extends AbstractJsonRpcViewer {
   moniker = MempoolViewerMoniker;
   async pendingBlocks(options) {
@@ -93442,8 +93489,8 @@ __publicField$2(NodeXyoViewer, "getArchivist", async (node, identifier) => {
 NodeXyoViewer = __decorateClass$2([
   creatableProvider()
 ], NodeXyoViewer);
-var SimpleXyoConnection = class extends AbstractCreatableProvider {
-  moniker = SimpleXyoConnection.defaultMoniker;
+var SimpleXyoConnectionRunner = class extends AbstractCreatableProvider {
+  moniker = SimpleXyoConnectionRunner.defaultMoniker;
   _network;
   _runner;
   _storage;
@@ -93469,15 +93516,15 @@ var SimpleXyoConnection = class extends AbstractCreatableProvider {
     this._storage = dataLakeRunner ?? dataLakeViewer;
   }
 };
-__publicField$2(SimpleXyoConnection, "defaultMoniker", XyoConnectionMoniker);
-__publicField$2(SimpleXyoConnection, "dependencies", [XyoRunnerMoniker, XyoViewerMoniker, DataLakeRunnerMoniker, DataLakeViewerMoniker]);
-__publicField$2(SimpleXyoConnection, "monikers", [XyoConnectionMoniker]);
-SimpleXyoConnection = __decorateClass$2([
+__publicField$2(SimpleXyoConnectionRunner, "defaultMoniker", XyoConnectionMoniker);
+__publicField$2(SimpleXyoConnectionRunner, "dependencies", [XyoRunnerMoniker, XyoViewerMoniker, DataLakeRunnerMoniker, DataLakeViewerMoniker]);
+__publicField$2(SimpleXyoConnectionRunner, "monikers", [XyoConnectionMoniker]);
+SimpleXyoConnectionRunner = __decorateClass$2([
   creatableProvider()
-], SimpleXyoConnection);
+], SimpleXyoConnectionRunner);
 var registerGatewayWithLocator = (locator, account) => {
   locator.registerMany([
-    SimpleXyoConnection.factory(SimpleXyoConnection.dependencies, {}),
+    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
     SimpleXyoGateway.factory(SimpleXyoGateway.dependencies, {})
   ]);
   if (account) {
@@ -93979,23 +94026,6 @@ function buildProviderLocator({ context = getEmptyProviderContext(ConfigZod.pars
     caches
   }, locator?.registry);
 }
-function buildSimpleProviderLocator(params) {
-  const locator = buildProviderLocator(params);
-  const positions = [];
-  locator.registerMany([
-    SimpleStakeViewer.factory(SimpleStakeViewer.dependencies, { positions }),
-    SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, { positions }),
-    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, {})
-  ]);
-  return registerGatewayWithLocator(locator, params?.signerAccount);
-}
 async function buildJsonRpcProviderLocator(params) {
   const locator = buildProviderLocator(params);
   const transportFactory = params.transportFactory;
@@ -94030,28 +94060,33 @@ async function buildJsonRpcProviderLocator(params) {
   ]);
   return registerGatewayWithLocator(locator, params?.signerAccount);
 }
-function buildLocalProviderLocator(params) {
-  const locator = buildSimpleProviderLocator(params);
-  const {
-    pendingTransactionsArchivist,
-    pendingBlocksArchivist,
-    balancesSummaryMap,
-    transfersSummaryMap,
-    finalizedArchivist,
-    node
-  } = params;
-  locator.registerMany([
-    SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
-    SimpleAccountBalanceViewer.factory(SimpleAccountBalanceViewer.dependencies, { balancesSummaryMap, transfersSummaryMap }),
-    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, { finalizedArchivist }),
-    SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, { finalizedArchivist }),
-    SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}),
-    SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 1e4, syncInterval: 1e4 }),
-    NodeXyoViewer.factory(NodeXyoViewer.dependencies, { node })
-  ]);
-  return registerGatewayWithLocator(locator, params?.signerAccount);
-}
+var SimpleXyoConnectionViewer = class extends AbstractCreatableProvider {
+  moniker = SimpleXyoConnectionViewer.defaultMoniker;
+  _network;
+  _storage;
+  _viewer;
+  get network() {
+    return this._network;
+  }
+  get storage() {
+    return this._storage;
+  }
+  get viewer() {
+    return this._viewer;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._viewer = await this.locator.getInstance(XyoViewerMoniker);
+    const dataLakeViewer = await this.locator.tryGetInstance(DataLakeViewerMoniker);
+    this._storage = dataLakeViewer;
+  }
+};
+__publicField$2(SimpleXyoConnectionViewer, "defaultMoniker", XyoConnectionMoniker);
+__publicField$2(SimpleXyoConnectionViewer, "dependencies", [XyoRunnerMoniker, XyoViewerMoniker, DataLakeRunnerMoniker, DataLakeViewerMoniker]);
+__publicField$2(SimpleXyoConnectionViewer, "monikers", [XyoConnectionMoniker]);
+SimpleXyoConnectionViewer = __decorateClass$2([
+  creatableProvider()
+], SimpleXyoConnectionViewer);
 
 // src/boundwitness/BlockBoundWitness.ts
 var BlockBoundWitnessJsonSchema = {
@@ -161993,11 +162028,6 @@ var expressMungExports = requireExpressMung();
 var mung = /*@__PURE__*/getDefaultExportFromCjs(expressMungExports);
 
 // src/Handler/asyncHandler.ts
-function asyncHandler(fn) {
-  return (req, res, next) => {
-    return Promise.resolve(fn(req, res, next)).catch(next);
-  };
-}
 var {
   colorize,
   combine,
@@ -175875,13 +175905,13 @@ var createGenesisBlock = /* @__PURE__ */ __name$e(async (initialBlockProducer, n
 
 // src/block/buildRandomChain.ts
 assertEx(asAddress("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
-function _ts_decorate$6(decorators, target, key, desc) {
+function _ts_decorate$9(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$e(_ts_decorate$6, "_ts_decorate");
+__name$e(_ts_decorate$9, "_ts_decorate");
 var SynchronousLmdbMap = class extends AbstractCreatable {
   static {
     __name$e(this, "SynchronousLmdbMap");
@@ -175945,7 +175975,7 @@ var SynchronousLmdbMap = class extends AbstractCreatable {
     });
   }
 };
-SynchronousLmdbMap = _ts_decorate$6([
+SynchronousLmdbMap = _ts_decorate$9([
   creatable()
 ], SynchronousLmdbMap);
 function _ts_decorate2$4(decorators, target, key, desc) {
@@ -198526,13 +198556,13 @@ var AbstractEvmRunner = class extends AbstractEvmViewer {
     };
   }
 };
-function _ts_decorate$5(decorators, target, key, desc) {
+function _ts_decorate$8(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$d(_ts_decorate$5, "_ts_decorate");
+__name$d(_ts_decorate$8, "_ts_decorate");
 var EvmChainContractViewer = class _EvmChainContractViewer extends AbstractEvmViewer {
   static {
     __name$d(this, "EvmChainContractViewer");
@@ -198615,7 +198645,7 @@ var EvmChainContractViewer = class _EvmChainContractViewer extends AbstractEvmVi
     return IStakedXyoChain__factory.connect(address, this.params.provider);
   }
 };
-EvmChainContractViewer = _ts_decorate$5([
+EvmChainContractViewer = _ts_decorate$8([
   creatableProvider()
 ], EvmChainContractViewer);
 function _ts_decorate2$3(decorators, target, key, desc) {
@@ -198636,7 +198666,7 @@ var EvmStakeRunner = class _EvmStakeRunner extends AbstractEvmRunner {
   ];
   moniker = _EvmStakeRunner.defaultMoniker;
   async addStake(staked, amount) {
-    const result = await this.contract.addStake(getAddress$2(toEthAddress(staked)), amount);
+    const result = await this.contract.addStake(getAddress(toEthAddress(staked)), amount);
     await result.wait();
     return true;
   }
@@ -198657,13 +198687,13 @@ var EvmStakeRunner = class _EvmStakeRunner extends AbstractEvmRunner {
 EvmStakeRunner = _ts_decorate2$3([
   creatableProvider()
 ], EvmStakeRunner);
-function _ts_decorate3$3(decorators, target, key, desc) {
+function _ts_decorate3$2(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$d(_ts_decorate3$3, "_ts_decorate");
+__name$d(_ts_decorate3$2, "_ts_decorate");
 var EvmStakeTotalsViewer = class _EvmStakeTotalsViewer extends AbstractEvmViewer {
   static {
     __name$d(this, "EvmStakeTotalsViewer");
@@ -198678,28 +198708,28 @@ var EvmStakeTotalsViewer = class _EvmStakeTotalsViewer extends AbstractEvmViewer
     return await this.contract.active();
   }
   async activeByStaked(staked) {
-    return await this.contract.activeByAddressStaked(getAddress$2(toEthAddress(staked)));
+    return await this.contract.activeByAddressStaked(getAddress(toEthAddress(staked)));
   }
   async activeByStaker(address) {
-    return await this.contract.activeByStaker(getAddress$2(toEthAddress(address)));
+    return await this.contract.activeByStaker(getAddress(toEthAddress(address)));
   }
   async pending() {
     return await this.contract.pending();
   }
   async pendingByStaker(staker) {
-    return await this.contract.pendingByStaker(getAddress$2(toEthAddress(staker)));
+    return await this.contract.pendingByStaker(getAddress(toEthAddress(staker)));
   }
   async withdrawn() {
     return await this.contract.withdrawn();
   }
   async withdrawnByStaker(staker) {
-    return await this.contract.withdrawnByStaker(getAddress$2(staker));
+    return await this.contract.withdrawnByStaker(getAddress(staker));
   }
   connectContract(address) {
     return IStakedXyoChain__factory.connect(address, this.params.provider);
   }
 };
-EvmStakeTotalsViewer = _ts_decorate3$3([
+EvmStakeTotalsViewer = _ts_decorate3$2([
   creatableProvider()
 ], EvmStakeTotalsViewer);
 var EthHashRegEx = HexRegExMinMaxMixedCaseWithPrefix(32, 32);
@@ -199613,13 +199643,13 @@ var BlockRewardDiviner = class extends AbstractDiviner {
 };
 asSchema("network.xyo.block.reward", true);
 var FixedPercentageBlockRewardDivinerConfigSchema = asSchema("network.xyo.diviner.chain.block.reward.fixed.percent.config", true);
-function _ts_decorate$4(decorators, target, key, desc) {
+function _ts_decorate$7(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$b(_ts_decorate$4, "_ts_decorate");
+__name$b(_ts_decorate$7, "_ts_decorate");
 var FixedPercentageBlockRewardDiviner = class extends BlockRewardDiviner {
   static {
     __name$b(this, "FixedPercentageBlockRewardDiviner");
@@ -199688,7 +199718,7 @@ var FixedPercentageBlockRewardDiviner = class extends BlockRewardDiviner {
     return rewards.filter(exists$2);
   }
 };
-FixedPercentageBlockRewardDiviner = _ts_decorate$4([
+FixedPercentageBlockRewardDiviner = _ts_decorate$7([
   creatableModule()
 ], FixedPercentageBlockRewardDiviner);
 var countDecimalPlaces = /* @__PURE__ */ __name$b((num) => {
@@ -199763,13 +199793,13 @@ var BlockValidationDiviner = class extends AbstractDiviner {
 BlockValidationDiviner = _ts_decorate2$2([
   creatableModule()
 ], BlockValidationDiviner);
-function _ts_decorate3$2(decorators, target, key, desc) {
+function _ts_decorate3$1(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$b(_ts_decorate3$2, "_ts_decorate");
+__name$b(_ts_decorate3$1, "_ts_decorate");
 var HeadValidationDivinerConfigSchema = asSchema("network.xyo.diviner.chain.head.validation.config", true);
 var HeadValidationDiviner = class extends AbstractDiviner {
   static {
@@ -199879,10 +199909,10 @@ var HeadValidationDiviner = class extends AbstractDiviner {
     });
   }
 };
-HeadValidationDiviner = _ts_decorate3$2([
+HeadValidationDiviner = _ts_decorate3$1([
   creatableModule()
 ], HeadValidationDiviner);
-async function processPendingBlocks({ blockViewer, context, finalizedArchivist, logger, mempoolViewer }) {
+async function processPendingBlocks({ blockViewer, context, logger, mempoolViewer, finalizationRunner }) {
   logger?.info("Starting processPendingBlocks");
   const start = Date.now();
   const currentBlock = await blockViewer.currentBlock();
@@ -199909,14 +199939,13 @@ async function processPendingBlocks({ blockViewer, context, finalizedArchivist,
     const blocksToFinalize = bestHeadChain.filter((b) => {
       return isDefined(oldHeadBlock) ? b[0].block > oldHeadBlock.block : true;
     });
-    const payloadsToFinalize = blocksToFinalize.flatMap((b) => flattenHydratedBlock(b));
     logger?.info("Validated new HeadBlock head from (block) in", `${Date.now() - start}ms`, newHeadBlock.block, "to", oldHeadBlock?.block);
     logger?.info("Validated new HeadBlock head from (hash) in", `${Date.now() - start}ms`, newHeadBlock._hash, "to", oldHeadBlock?._hash);
-    if (payloadsToFinalize.length > 0) {
-      await finalizedArchivist.insert(payloadsToFinalize);
+    if (blocksToFinalize.length > 0) {
+      await finalizationRunner.finalizeBlocks(blocksToFinalize);
     }
     await headSelector.finalizeChainFragment(blocksToFinalize);
-    return payloadsToFinalize;
+    return blocksToFinalize;
   } else {
     logger?.info("No head found to validate", currentBlock?.[0]._hash);
   }
@@ -200947,13 +200976,13 @@ __name$a(spanDurationInMillis, "spanDurationInMillis");
 
 var __defProp$b = Object.defineProperty;
 var __name$9 = (target, value) => __defProp$b(target, "name", { value, configurable: true });
-function _ts_decorate$3(decorators, target, key, desc) {
+function _ts_decorate$6(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$9(_ts_decorate$3, "_ts_decorate");
+__name$9(_ts_decorate$6, "_ts_decorate");
 var EvmBlockRewardViewer = class _EvmBlockRewardViewer extends AbstractCreatable {
   static {
     __name$9(this, "EvmBlockRewardViewer");
@@ -200987,7 +201016,7 @@ var EvmBlockRewardViewer = class _EvmBlockRewardViewer extends AbstractCreatable
     }
   }
 };
-EvmBlockRewardViewer = _ts_decorate$3([
+EvmBlockRewardViewer = _ts_decorate$6([
   creatable()
 ], EvmBlockRewardViewer);
 (class extends AbstractCreatableProvider {
@@ -201087,13 +201116,13 @@ var createBootstrapHead = /* @__PURE__ */ __name$9(async (account, chainId, gene
   chain.push(producerDeclarationBlock);
   return chain;
 }, "createBootstrapHead");
-function _ts_decorate3$1(decorators, target, key, desc) {
+function _ts_decorate3(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$9(_ts_decorate3$1, "_ts_decorate");
+__name$9(_ts_decorate3, "_ts_decorate");
 var BaseNetworkStakeStepRewardService = class _BaseNetworkStakeStepRewardService extends AbstractCreatableProvider {
   static {
     __name$9(this, "BaseNetworkStakeStepRewardService");
@@ -201159,7 +201188,7 @@ var BaseNetworkStakeStepRewardService = class _BaseNetworkStakeStepRewardService
     throw new Error("Method [networkStakeStepRewardsForStepLevel] not implemented.");
   }
 };
-BaseNetworkStakeStepRewardService = _ts_decorate3$1([
+BaseNetworkStakeStepRewardService = _ts_decorate3([
   creatableProvider()
 ], BaseNetworkStakeStepRewardService);
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name$9(async (payload) => {
@@ -293913,151 +293942,36 @@ var boot = /* @__PURE__ */ __name$7(() => genericBoot(getBiosExternalInterface),
 
 var __defProp$6 = Object.defineProperty;
 var __name$6 = (target, value) => __defProp$6(target, "name", { value, configurable: true });
-(class extends Actor {
-  static {
-    __name$6(this, "BalanceActor");
-  }
-  _updateMutex = new Mutex$1();
-  get accountBalanceViewer() {
-    return assertEx(this.params.accountBalanceViewer, () => "balanceService not set");
-  }
-  get blockViewer() {
-    return assertEx(this.params.blockViewer, () => "blockViewer not set");
-  }
-  async startHandler() {
-    await super.startHandler();
-    this.registerTimer(
-      "BalanceTimer",
-      async () => {
-        await this.updateBalance();
-      },
-      1e3,
-      1e4
-      /* 1000 */
-    );
-  }
-  async updateBalance() {
-    if (this._updateMutex.isLocked()) return;
-    await this._updateMutex.runExclusive(async () => {
-      const head = await this.blockViewer.currentBlockHash();
-      await this.accountBalanceViewer.accountBalances([], {
-        head
-      });
-    });
-  }
-});
-function _ts_decorate$2(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$6(_ts_decorate$2, "_ts_decorate");
-var MempoolActor = class extends Actor {
-  static {
-    __name$6(this, "MempoolActor");
-  }
-  _blockTimerId = null;
-  _blockTimerMutex = new Mutex$1();
-  _transactionTimerId = null;
-  _transactionTimerMutex = new Mutex$1();
-  get mempoolRunner() {
-    return this.params.mempoolRunner;
-  }
-  get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist;
-  }
-  get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist;
-  }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      mempoolRunner: assertEx(params?.mempoolRunner, () => "mempoolRunner is required for MempoolActor"),
-      pendingBlocksArchivist: assertEx(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required for MempoolActor"),
-      pendingTransactionsArchivist: assertEx(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required for MempoolActor")
-    };
-  }
-  async startHandler() {
-    await super.startHandler();
-    this.restartBlockTimer();
-  }
-  async stopHandler() {
-    await super.stopHandler();
-    this.stopBlockTimer();
-  }
-  restartBlockTimer() {
-    this.stopBlockTimer();
-    this._blockTimerId = setInterval(() => {
-      if (this._blockTimerMutex.isLocked()) {
-        return;
-      }
-      void this._blockTimerMutex.runExclusive(async () => {
-        await this.mempoolRunner.prunePendingBlocks({
-          batchSize: 50
-        });
-      });
-    }, 1e3);
-  }
-  restartTransactionTimer() {
-    this.stopTransactionTimer();
-    this._transactionTimerId = setInterval(() => {
-      if (this._transactionTimerMutex.isLocked()) {
-        return;
-      }
-      void this._transactionTimerMutex.runExclusive(async () => {
-        await this.mempoolRunner.prunePendingTransactions({
-          batchSize: 50
-        });
-      });
-    }, 1e3);
-  }
-  stopBlockTimer() {
-    if (this._blockTimerId !== null) {
-      clearInterval(this._blockTimerId);
-    }
-    this._blockTimerId = null;
-  }
-  stopTransactionTimer() {
-    if (this._transactionTimerId !== null) {
-      clearInterval(this._transactionTimerId);
-    }
-    this._transactionTimerId = null;
-  }
-};
-MempoolActor = _ts_decorate$2([
-  creatable()
-], MempoolActor);
-function _ts_decorate2(decorators, target, key, desc) {
+function _ts_decorate$5(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$6(_ts_decorate2, "_ts_decorate");
-var ValidatorActor = class extends Actor {
+__name$6(_ts_decorate$5, "_ts_decorate");
+var ValidatorActor = class extends ActorV3 {
   static {
     __name$6(this, "ValidatorActor");
   }
+  _blockViewer;
+  _finalizationRunner;
   _lastValidatedBlock;
   _lastValidatedBlockHash;
+  _mempoolViewer;
   get blockViewer() {
-    return this.params.blockViewer;
+    return this._blockViewer;
   }
-  get finalizedArchivist() {
-    return assertEx(this.params.finalizedArchivist, () => "finalizedArchivist not set");
+  get finalizationRunner() {
+    return this._finalizationRunner;
   }
   get mempoolViewer() {
-    return this.params.mempoolViewer;
+    return this._mempoolViewer;
   }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      mempoolViewer: assertEx(params?.mempoolViewer, () => "mempoolViewer is required for ValidatorActor"),
-      blockViewer: assertEx(params?.blockViewer, () => "blockViewer is required for ValidatorActor"),
-      finalizedArchivist: assertEx(params?.finalizedArchivist, () => "finalizedArchivist is required for ValidatorActor"),
-      account: assertEx(params?.account, () => "account is required for ValidatorActor")
-    };
+  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();
@@ -294071,7 +293985,7 @@ var ValidatorActor = class extends Actor {
             logger: this.logger,
             mempoolViewer: this.mempoolViewer,
             blockViewer: this.blockViewer,
-            finalizedArchivist: this.finalizedArchivist
+            finalizationRunner: this.finalizationRunner
           });
         }, {
           ...this.context,
@@ -294083,18 +293997,8 @@ var ValidatorActor = class extends Actor {
       /* 500 */
     );
   }
-  async slashInvalidBlock(_block) {
-    const slashed = await Promise.resolve(true);
-    return slashed;
-  }
-  async validateBlock(block) {
-    const valid = await Promise.resolve(true);
-    this._lastValidatedBlock = block;
-    this._lastValidatedBlockHash = await PayloadBuilder.hash(block);
-    return valid;
-  }
 };
-ValidatorActor = _ts_decorate2([
+ValidatorActor = _ts_decorate$5([
   creatable()
 ], ValidatorActor);
 var DEFAULT_STORAGE_ROOT = path__default.join(process.cwd(), ".store");
@@ -294291,58 +294195,6 @@ var initEvmProvider = /* @__PURE__ */ __name$6(async ({ config }) => {
 var canUseEvmProvider = /* @__PURE__ */ __name$6(({ config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
 }, "canUseEvmProvider");
-var sendStatus = /* @__PURE__ */ __name$6((res, status, errorCode) => {
-  const statusCode = status === "started" ? 200 : errorCode;
-  res.writeHead(statusCode, {
-    "Content-Type": "application/json"
-  });
-  res.end(JSON.stringify({
-    status
-  }));
-}, "sendStatus");
-var notFound = /* @__PURE__ */ __name$6((res) => {
-  res.writeHead(404, {
-    "Content-Type": "application/json"
-  });
-  res.end(JSON.stringify({
-    status: "not found"
-  }));
-}, "notFound");
-var createHealthServer = /* @__PURE__ */ __name$6((port, statusMonitor, logger) => {
-  const server = require$$0$d.createServer((req, res) => {
-    const url = req.url ?? "";
-    const status = statusMonitor.getGlobalStatus();
-    switch (url) {
-      case "/healthz": {
-        sendStatus(res, status, 500);
-        break;
-      }
-      case "/livez": {
-        sendStatus(res, status, 503);
-        break;
-      }
-      case "/readyz": {
-        sendStatus(res, status, 503);
-        break;
-      }
-      default: {
-        notFound(res);
-      }
-    }
-  });
-  server.listen(port, () => {
-    logger.log(`Health server running on http://localhost:${port}`);
-    logger.log(" - /healthz");
-    logger.log(" - /livez");
-    logger.log(" - /readyz");
-  });
-  return server;
-}, "createHealthServer");
-var initHealthEndpoints = /* @__PURE__ */ __name$6((params) => {
-  const { config, logger, statusReporter } = params;
-  const { healthCheckPort } = config.actors.producer;
-  return isDefined(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : void 0;
-}, "initHealthEndpoints");
 
 // src/host/implementation/DefaultHost.ts
 (class {
@@ -294851,6 +294703,14 @@ async function initApiWallet({ config, logger }) {
   }, mnemonic);
 }
 __name$6(initApiWallet, "initApiWallet");
+async function initBridgeWallet({ config, logger }) {
+  const { mnemonic } = config.actors.bridge;
+  return await initWallet({
+    config,
+    logger
+  }, mnemonic);
+}
+__name$6(initBridgeWallet, "initBridgeWallet");
 async function initMempoolWallet({ config, logger }) {
   const { mnemonic } = config.actors.mempool;
   return await initWallet({
@@ -294875,13 +294735,21 @@ async function initRewardsRedemptionApiWallet({ config, logger }) {
   }, mnemonic);
 }
 __name$6(initRewardsRedemptionApiWallet, "initRewardsRedemptionApiWallet");
-function _ts_decorate3(decorators, target, key, desc) {
+async function initValidatorWallet({ config, logger }) {
+  const { mnemonic } = config.actors.mempool;
+  return await initWallet({
+    config,
+    logger
+  }, mnemonic);
+}
+__name$6(initValidatorWallet, "initValidatorWallet");
+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$6(_ts_decorate3, "_ts_decorate");
+__name$6(_ts_decorate2, "_ts_decorate");
 var Orchestrator = class extends AbstractCreatable {
   static {
     __name$6(this, "Orchestrator");
@@ -294934,13 +294802,13 @@ var Orchestrator = class extends AbstractCreatable {
     this.logger?.log("[Orchestrator] Stopped...");
   }
 };
-Orchestrator = _ts_decorate3([
+Orchestrator = _ts_decorate2([
   creatable()
 ], Orchestrator);
 
 var __defProp$5 = Object.defineProperty;
 var __name$5 = (target, value) => __defProp$5(target, "name", { value, configurable: true });
-var addInstrumentation$3 = /* @__PURE__ */ __name$5(() => {
+var addInstrumentation$2 = /* @__PURE__ */ __name$5(() => {
   const instrumentations = [
     new HttpInstrumentation(),
     new ExpressInstrumentation()
@@ -294949,147 +294817,19 @@ var addInstrumentation$3 = /* @__PURE__ */ __name$5(() => {
     instrumentations
   });
 }, "addInstrumentation");
-var handler$1 = /* @__PURE__ */ __name$5(async (req, res, next) => {
-  const { address: moduleIdentifier } = req.params;
-  const { node } = req.app.context;
-  const address = asAddress(moduleIdentifier);
-  if (isDefined(address)) {
-    let mod = node.address === address ? node : await node.resolve(address, {
-      direction: "down"
-    });
-    if (mod) {
-      res.json(await mod.state());
-      return;
-    }
-  }
-  if (isModuleName(moduleIdentifier)) {
-    const mod = await node.resolve(moduleIdentifier, {
-      direction: "down"
-    });
-    if (mod) {
-      res.redirect(StatusCodes.MOVED_TEMPORARILY, `/${mod.address}`);
-      return;
-    }
-  }
-  next("route");
-}, "handler");
-var getAddress$1 = asyncHandler(handler$1);
-var DEFAULT_DEPTH$1 = 5;
-var getQueryConfig$1 = /* @__PURE__ */ __name$5((mod, req, bw, payloads) => {
-  const nestedBwAddresses = payloads?.flat(DEFAULT_DEPTH$1).filter((payload) => payload?.schema === BoundWitnessSchema).map((bw2) => bw2.addresses) ?? [];
-  const addresses = [
-    bw.addresses,
-    ...nestedBwAddresses
-  ].filter((address) => address.length > 0);
-  const allowed = addresses.length > 0 ? Object.fromEntries(mod.queries.map((schema) => [
-    schema,
-    addresses
-  ])) : {};
-  const security = {
-    allowed
-  };
-  return {
-    schema: ModuleConfigSchema,
-    security
-  };
-}, "getQueryConfig");
-
-// src/server/routes/address/post/post.ts
-var handler2$1 = /* @__PURE__ */ __name$5(async (req, res, next) => {
-  const returnError = /* @__PURE__ */ __name$5((code, message = "An error occurred", details) => {
-    const error = new ModuleErrorBuilder().message(message).details(details).build();
-    res.locals.rawResponse = false;
-    res.status(code).json(error);
-    next();
-  }, "returnError");
-  const { address } = req.params;
-  const { node } = req.app.context;
-  const [bw, payloads] = Array.isArray(req.body) ? req.body : [];
-  if (!isAddress(address)) {
-    return returnError(StatusCodes.BAD_REQUEST, "Missing address");
-  }
-  if (!bw) {
-    return returnError(StatusCodes.BAD_REQUEST, "Missing boundwitness");
-  }
-  if (!isQueryBoundWitness(bw)) {
-    return returnError(StatusCodes.BAD_REQUEST, "Invalid query boundwitness");
-  }
-  let modules = [];
-  const normalizedAddress = toAddress(address);
-  if (node.address === normalizedAddress) modules = [
-    node
-  ];
-  else {
-    const typedAddress = asAddress(address);
-    const byAddress = typedAddress === void 0 ? void 0 : await node.resolve(typedAddress, {
-      maxDepth: 10
-    });
-    if (byAddress) modules = [
-      byAddress
-    ];
-    else {
-      const byName = await node.resolve(address, {
-        direction: "down"
-      });
-      if (byName) {
-        const moduleAddress = assertEx(byName?.address, () => "Error redirecting to module by address");
-        res.redirect(StatusCodes.TEMPORARY_REDIRECT, `/${moduleAddress}`);
-        return;
-      } else {
-        return returnError(StatusCodes.NOT_FOUND, "Module not found", {
-          address
-        });
-      }
-    }
-  }
-  if (modules.length > 0) {
-    const mod = modules[0];
-    const queryConfig = getQueryConfig$1(mod, req, bw, payloads);
-    try {
-      const queryResult = await mod.query(bw, payloads, queryConfig);
-      res.json(queryResult);
-    } catch (ex) {
-      return returnError(StatusCodes.INTERNAL_SERVER_ERROR, "Query Failed", {
-        message: ex?.message ?? "Unknown Error"
-      });
-    }
-  } else {
-    return returnError(StatusCodes.NOT_FOUND, "Module not found", {
-      address
-    });
-  }
-}, "handler");
-var postAddress$1 = asyncHandler(handler2$1);
-
-// src/server/routes/address/addNodeRoutes.ts
-var addNodeRoutes$1 = /* @__PURE__ */ __name$5((app) => {
-  const defaultModule = app.context.node;
-  const address = defaultModule.address;
-  const defaultModuleEndpoint = `/${address}`;
-  app.get("/", (_req, res) => res.redirect(StatusCodes.MOVED_TEMPORARILY, defaultModuleEndpoint));
-  app.post("/", (_req, res) => res.redirect(StatusCodes.TEMPORARY_REDIRECT, defaultModuleEndpoint));
-  app.get("/:address", getAddress$1);
-  app.post("/:address", postAddress$1);
-  app.get("/:hash", (_req, res) => {
-    res.sendStatus(StatusCodes.NOT_FOUND);
-  });
-  app.post("/:hash", (_req, res) => {
-    res.sendStatus(StatusCodes.NOT_FOUND);
-  });
-}, "addNodeRoutes");
-var resolveArchivist$2 = /* @__PURE__ */ __name$5(async (node, archivistModuleIdentifier) => {
+var resolveArchivist$1 = /* @__PURE__ */ __name$5(async (node, archivistModuleIdentifier) => {
   const mod = await node.resolve(archivistModuleIdentifier);
   return asArchivistInstance(mod, {
     required: true
   });
 }, "resolveArchivist");
-var archivistInstance$2;
-var getArchivist$2 = /* @__PURE__ */ __name$5(async (node, archivistModuleIdentifier) => {
-  if (isDefined(archivistInstance$2)) return archivistInstance$2;
-  archivistInstance$2 = await resolveArchivist$2(node, archivistModuleIdentifier);
-  return archivistInstance$2;
+var archivistInstance$1;
+var getArchivist$1 = /* @__PURE__ */ __name$5(async (node, archivistModuleIdentifier) => {
+  if (isDefined(archivistInstance$1)) return archivistInstance$1;
+  archivistInstance$1 = await resolveArchivist$1(node, archivistModuleIdentifier);
+  return archivistInstance$1;
 }, "getArchivist");
-var archivistMiddleware$2 = /* @__PURE__ */ __name$5((options) => {
+var archivistMiddleware$1 = /* @__PURE__ */ __name$5((options) => {
   const { node, archivistModuleIdentifier } = options;
   const router = express2.Router({
     mergeParams: true
@@ -295100,7 +294840,7 @@ var archivistMiddleware$2 = /* @__PURE__ */ __name$5((options) => {
       req.body
     ];
     const payloads = (await PayloadBuilder.hashPairs(body)).map((p) => p[0]);
-    const archivist = await getArchivist$2(node, archivistModuleIdentifier);
+    const archivist = await getArchivist$1(node, archivistModuleIdentifier);
     const result = await archivist.insert(payloads);
     res.status(200).json(result);
   });
@@ -295116,14 +294856,14 @@ var archivistMiddleware$2 = /* @__PURE__ */ __name$5((options) => {
       order,
       cursor
     };
-    const archivist = await getArchivist$2(node, archivistModuleIdentifier);
+    const archivist = await getArchivist$1(node, archivistModuleIdentifier);
     const result = await archivist.next(options2);
     res.status(200).json(result);
   });
   router.post("/next", async (req, res) => {
     setRawResponseFormat(res);
     const options2 = req.body;
-    const archivist = await getArchivist$2(node, archivistModuleIdentifier);
+    const archivist = await getArchivist$1(node, archivistModuleIdentifier);
     const result = await (isDefined(options2) ? archivist.next(options2) : archivist.next());
     res.status(200).json(result);
   });
@@ -295132,7 +294872,7 @@ var archivistMiddleware$2 = /* @__PURE__ */ __name$5((options) => {
     const { hash: rawHash } = req.params;
     const hash = asHash(rawHash);
     if (isDefined(hash)) {
-      const archivist = await getArchivist$2(node, archivistModuleIdentifier);
+      const archivist = await getArchivist$1(node, archivistModuleIdentifier);
       const [payload] = await archivist.get([
         hash
       ]);
@@ -295147,10 +294887,10 @@ var archivistMiddleware$2 = /* @__PURE__ */ __name$5((options) => {
 }, "archivistMiddleware");
 
 // src/server/routes/dataLake/addDataLakeRoutes.ts
-var addDataLakeRoutes$2 = /* @__PURE__ */ __name$5((app) => {
+var addDataLakeRoutes$1 = /* @__PURE__ */ __name$5((app) => {
   const { node } = app.context;
   const archivistModuleIdentifier = "Chain:Finalized";
-  app.use("/chain", archivistMiddleware$2({
+  app.use("/chain", archivistMiddleware$1({
     node,
     archivistModuleIdentifier
   }));
@@ -295169,15 +294909,14 @@ var addRpcRoutes = /* @__PURE__ */ __name$5(async (app) => {
 }, "addRpcRoutes");
 
 // src/server/routes/addRoutes.ts
-var addRoutes$3 = /* @__PURE__ */ __name$5(async (app) => {
+var addRoutes$2 = /* @__PURE__ */ __name$5(async (app) => {
   await addRpcRoutes(app);
-  addDataLakeRoutes$2(app);
-  addNodeRoutes$1(app);
+  addDataLakeRoutes$1(app);
 }, "addRoutes");
 
 // src/server/app.ts
-var getApp$3 = /* @__PURE__ */ __name$5(async (context) => {
-  addInstrumentation$3();
+var getApp$2 = /* @__PURE__ */ __name$5(async (context) => {
+  addInstrumentation$2();
   const app = express2();
   app.set("etag", false);
   app.use(cors());
@@ -295191,164 +294930,36 @@ var getApp$3 = /* @__PURE__ */ __name$5(async (context) => {
   app.use(customPoweredByHeader);
   disableCaseSensitiveRouting(app);
   app.context = context;
-  await addRoutes$3(app);
+  await addRoutes$2(app);
   app.use(standardErrors);
   return app;
 }, "getApp");
-async function initApiParams(params) {
-  const { config, node: providedNode } = params;
-  const logger = assertEx(params.logger, () => "Logger is required to init server");
-  const statusReporter = initStatusReporter({
-    logger
-  });
-  await startupSpanAsync("initHealthEndpoints", () => initHealthEndpoints({
-    config,
-    logger,
-    statusReporter
-  }));
-  const telemetryConfig = buildTelemetryConfig(config, "xl1-api", "1.0.0", DefaultMetricsScrapePorts.api);
-  const { traceProvider, meterProvider } = await startupSpanAsync("initTelemetry", () => initTelemetry(telemetryConfig));
-  const initContext = {
-    _id: "init-context",
-    config,
-    logger,
-    statusReporter,
-    timeBudgetLimit: 1e3,
-    meterProvider,
-    traceProvider,
-    singletons: {},
-    caches: {}
-  };
-  const wallet = await initApiWallet(initContext);
-  const balancesSummaryMap = assertEx(await initBalanceSummaryMap(initContext), () => "Balance Summary Map not initialized");
-  const transfersSummaryMap = assertEx(await initTransferSummaryMap(initContext), () => "Transfer Summary Map not initialized");
-  const { node, writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist } = await initServerNode({
-    ...initContext,
-    wallet,
-    node: providedNode,
-    transfersSummaryMap,
-    balancesSummaryMap
-  });
-  await writableChainArchivist.start();
-  await readonlyChainArchivist.start();
-  await pendingTransactionsArchivist.start();
-  await pendingBlocksArchivist.start();
-  const [head, chainId] = await initFinalizationArchivistIfNeeded(writableChainArchivist, config, wallet);
-  assertEx(head.chain === chainId, () => `Chain ID does not match head block chain ID [init] [${head.chain} !== ${chainId}]`);
-  const mods = await node.resolve("*");
-  await Promise.all(mods.map((mod) => {
-    return mod.start?.() ?? (() => true);
-  }));
-  const locator = buildLocalProviderLocator({
-    context: initContext,
-    finalizedArchivist: writableChainArchivist,
-    pendingTransactionsArchivist,
-    pendingBlocksArchivist,
-    balancesSummaryMap,
-    transfersSummaryMap,
-    node
-  });
-  await initEvmProvidersIfAvailable(locator);
-  locator.register(SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
-    state: validateHydratedBlockState,
-    protocol: validateHydratedBlock
-  }));
-  locator.register(SimpleXyoConnection.factory(SimpleXyoConnection.dependencies, {}));
-  const apiContext = {
-    ...initContext,
-    ...locator.context,
-    _id: "api-context",
-    node
-  };
-  const blockViewer = await locator.getInstance(BlockViewerMoniker);
-  assertEx(await blockViewer.start(), () => "Failed to start BlockViewer");
-  const blk = await blockViewer.currentBlock();
-  assertEx(blk, () => "No blocks found after initialization");
-  const accountBalanceViewer = await locator.getInstance(AccountBalanceViewerMoniker);
-  assertEx(await accountBalanceViewer.start(), () => "Failed to start AccountBalanceViewer");
-  const xyoViewer = await locator.getInstance(XyoViewerMoniker);
-  assertEx(await xyoViewer.start(), () => "Failed to start XyoViewer");
-  const mempoolViewer = await locator.getInstance(MempoolViewerMoniker);
-  assertEx(await mempoolViewer.start(), () => "Failed to start MempoolViewer");
-  const mempoolRunner = await locator.getInstance(MempoolRunnerMoniker);
-  assertEx(await mempoolRunner.start(), () => "Failed to start MempoolRunner");
-  console.info(`[API] Current block after initialization: #${blk[0].block} (${blk[0]._hash})`);
-  const validatorActor = config.actors.mempool.enabled ? void 0 : await ValidatorActor.create({
-    id: "validator-mempool-server",
-    account: wallet,
-    context: locator.context,
-    finalizedArchivist: writableChainArchivist,
-    mempoolViewer,
-    blockViewer
-  });
-  await validatorActor?.start();
-  const mempoolActor = config.actors.mempool.enabled ? void 0 : await MempoolActor.create({
-    id: "mempool-mempool-server",
-    account: wallet,
-    context: locator.context,
-    mempoolRunner,
-    pendingBlocksArchivist,
-    pendingTransactionsArchivist
-  });
-  await mempoolActor?.start();
-  return {
-    id: "api-actor",
-    account: wallet,
-    context: apiContext,
-    transfersSummaryMap,
-    balancesSummaryMap
-  };
-}
-__name$5(initApiParams, "initApiParams");
 
 // src/server/server.ts
-var hostname$3 = "::";
-async function getServer$3(context) {
+var hostname$2 = "::";
+async function getServer$2(context) {
   const { logger } = context;
   const { port } = context.config.actors.api;
-  const app = await getApp$3(context);
-  const server = app.listen(port, hostname$3, () => logger?.log(`[API] Server listening at http://${hostname$3}:${port}`));
+  const app = await getApp$2(context);
+  const server = app.listen(port, hostname$2, () => logger?.info(`[API] Server listening at http://${hostname$2}:${port}`));
   server.setTimeout(2e4);
   return server;
 }
-__name$5(getServer$3, "getServer");
+__name$5(getServer$2, "getServer");
 
 // src/ApiActor.ts
-function _ts_decorate$1(decorators, target, key, desc) {
+function _ts_decorate$4(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$5(_ts_decorate$1, "_ts_decorate");
-var ApiActor = class extends Actor {
+__name$5(_ts_decorate$4, "_ts_decorate");
+var ApiActor = class extends ActorV3 {
   static {
     __name$5(this, "ApiActor");
   }
   server;
-  get context() {
-    return this.params.context;
-  }
-  static defaultFactories() {
-    return [
-      ...super.defaultFactories()
-    ];
-  }
-  static async paramsHandler(params) {
-    const logger = params?.context?.logger;
-    let account = params?.account;
-    if (account === void 0) {
-      const newAccount = await Account.random();
-      logger?.warn(`No account provided to ApiActor, generating random account ${newAccount.address}`);
-      account = newAccount;
-    }
-    logger?.info(`Running api for account ${account.address}`);
-    return {
-      ...await super.paramsHandler(params),
-      context: params.context,
-      account: assertEx(account, () => "ApiActor requires an account to run")
-    };
-  }
   async createHandler() {
     await super.createHandler();
   }
@@ -295362,25 +294973,26 @@ var ApiActor = class extends Actor {
     this.stopServer();
   }
   async startServer() {
-    this.server = await getServer$3(this.context);
+    this.server = await getServer$2(this.context);
   }
   stopServer() {
     this.server?.close();
     this.server = void 0;
   }
 };
-ApiActor = _ts_decorate$1([
+ApiActor = _ts_decorate$4([
   creatable()
 ], ApiActor);
-var runApi = /* @__PURE__ */ __name$5(async ({ config, orchestrator, ...params }) => {
-  const logger = new IdLogger(params.logger ?? console, () => "API");
-  const account = await Account.random();
-  logger.info(`Running api for account ${account.address} [random]`);
-  const actorParams = await initApiParams({
+var runApi = /* @__PURE__ */ __name$5(async (config, orchestrator, locator) => {
+  const account = await initApiWallet({
     config,
-    logger
+    logger: locator.context.logger
+  });
+  const api = await ApiActor.create({
+    account,
+    config,
+    locator
   });
-  const api = await ApiActor.create(actorParams);
   const actors = [
     api
   ].filter(exists$2);
@@ -295392,22 +295004,118 @@ var runApi = /* @__PURE__ */ __name$5(async ({ config, orchestrator, ...params }
 
 var __defProp$4 = Object.defineProperty;
 var __name$4 = (target, value) => __defProp$4(target, "name", { value, configurable: true });
-function _ts_decorate(decorators, target, key, desc) {
+function _ts_decorate$3(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$4(_ts_decorate, "_ts_decorate");
+__name$4(_ts_decorate$3, "_ts_decorate");
+var MempoolActor = class extends ActorV3 {
+  static {
+    __name$4(this, "MempoolActor");
+  }
+  _mempoolRunner;
+  _blockTimerId = null;
+  _blockTimerMutex = new Mutex$1();
+  _transactionTimerId = null;
+  _transactionTimerMutex = new Mutex$1();
+  get mempoolRunner() {
+    return this._mempoolRunner;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._mempoolRunner = await this.locator.getInstance(MempoolRunnerMoniker);
+  }
+  async startHandler() {
+    await super.startHandler();
+    this.restartTransactionTimer();
+    this.restartBlockTimer();
+  }
+  async stopHandler() {
+    await super.stopHandler();
+    this.stopTransactionTimer();
+    this.stopBlockTimer();
+  }
+  restartBlockTimer() {
+    this.stopBlockTimer();
+    this._blockTimerId = setInterval(() => {
+      if (this._blockTimerMutex.isLocked()) {
+        return;
+      }
+      void this._blockTimerMutex.runExclusive(async () => {
+        await this.mempoolRunner.prunePendingBlocks({
+          batchSize: 50
+        });
+      });
+    }, 1e3);
+  }
+  restartTransactionTimer() {
+    this.stopTransactionTimer();
+    this._transactionTimerId = setInterval(() => {
+      if (this._transactionTimerMutex.isLocked()) {
+        return;
+      }
+      void this._transactionTimerMutex.runExclusive(async () => {
+        await this.mempoolRunner.prunePendingTransactions({
+          batchSize: 50
+        });
+      });
+    }, 1e3);
+  }
+  stopBlockTimer() {
+    if (this._blockTimerId !== null) {
+      clearInterval(this._blockTimerId);
+    }
+    this._blockTimerId = null;
+  }
+  stopTransactionTimer() {
+    if (this._transactionTimerId !== null) {
+      clearInterval(this._transactionTimerId);
+    }
+    this._transactionTimerId = null;
+  }
+};
+MempoolActor = _ts_decorate$3([
+  creatable()
+], MempoolActor);
+var runMempool = /* @__PURE__ */ __name$4(async (config, orchestrator, locator) => {
+  const account = await initMempoolWallet({
+    config,
+    logger: locator.context.logger
+  });
+  const mempool = await MempoolActor.create({
+    account,
+    config,
+    locator
+  });
+  const actors = [
+    mempool
+  ].filter(exists$2);
+  for (const actor of actors) {
+    await orchestrator.registerActor(actor);
+  }
+  await orchestrator.start();
+}, "runMempool");
+
+var __defProp$3 = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+function _ts_decorate$2(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$3(_ts_decorate$2, "_ts_decorate");
 var TEN_MINUTES = 10 * 60 * 1e3;
-var toFormattedBlockReference = /* @__PURE__ */ __name$4((blockBoundWitness) => {
+var toFormattedBlockReference = /* @__PURE__ */ __name$3((blockBoundWitness) => {
   return `${blockBoundWitness.block} [${toHex(blockBoundWitness._hash, {
     prefix: true
   })}]`;
 }, "toFormattedBlockReference");
 var ProducerActor = class _ProducerActor extends ActorV3 {
   static {
-    __name$4(this, "ProducerActor");
+    __name$3(this, "ProducerActor");
   }
   /**
   * The interval time (in MS) between block production attempts.
@@ -295438,7 +295146,6 @@ var ProducerActor = class _ProducerActor extends ActorV3 {
   _mempoolRunner;
   _mempoolViewer;
   _produceBlockMutex = new Mutex$1();
-  _rewardAddress;
   _stakeTotalsViewer;
   get logger() {
     return assertEx(super.logger, () => "Logger is required for ProducerActor");
@@ -295657,10 +295364,10 @@ var ProducerActor = class _ProducerActor extends ActorV3 {
     return true;
   }
 };
-ProducerActor = _ts_decorate([
+ProducerActor = _ts_decorate$2([
   creatable()
 ], ProducerActor);
-var runProducer = /* @__PURE__ */ __name$4(async (config, orchestrator, locator) => {
+var runProducer = /* @__PURE__ */ __name$3(async (config, orchestrator, locator) => {
   const account = await initProducerAccount({
     config,
     logger: locator.context.logger
@@ -342486,11 +342193,11 @@ var ClientType;
     ClientType["normal"] = "normal";
 })(ClientType || (ClientType = {}));
 
-var __defProp$3 = Object.defineProperty;
-var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
 var connection;
 var maxRetriesPerRequest = null;
-var getConnection = /* @__PURE__ */ __name$3((config) => {
+var getConnection = /* @__PURE__ */ __name$2((config) => {
   if (isDefined(connection)) return connection;
   const { redisHost: host, redisPort: port } = config.actors.bridge;
   connection = new builtExports.Redis({
@@ -342501,7 +342208,7 @@ var getConnection = /* @__PURE__ */ __name$3((config) => {
   return connection;
 }, "getConnection");
 var flowProducer;
-var getFlowProducer = /* @__PURE__ */ __name$3((connection2) => {
+var getFlowProducer = /* @__PURE__ */ __name$2((connection2) => {
   if (isDefined(flowProducer)) return flowProducer;
   flowProducer = new FlowProducer({
     connection: connection2
@@ -342510,7 +342217,7 @@ var getFlowProducer = /* @__PURE__ */ __name$3((connection2) => {
 }, "getFlowProducer");
 
 // src/queue/workers/createWorkers.ts
-var createWorkers = /* @__PURE__ */ __name$3((connection2, services) => {
+var createWorkers = /* @__PURE__ */ __name$2((connection2, services) => {
   Xl1ToEthBridgeParent.createWorker(connection2);
   Xl1TransactionPreparation.createWorker(connection2, services);
   Xl1TransactionSubmission.createWorker(connection2, services);
@@ -342521,7 +342228,7 @@ var createWorkers = /* @__PURE__ */ __name$3((connection2, services) => {
 }, "createWorkers");
 var name = "Monitor Submitted ETH Transaction";
 var queueName = "eth-tx-monitor";
-var createWorker = /* @__PURE__ */ __name$3((connection2, services) => {
+var createWorker = /* @__PURE__ */ __name$2((connection2, services) => {
   const provider = assertEx(services?.provider, () => "provider service not provided");
   const stateMap = assertEx(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
   const worker = new Worker(queueName, async (job) => {
@@ -342555,7 +342262,7 @@ var EthTransactionMonitor = {
 };
 var name2 = "Prepare ETH Transaction";
 var queueName2 = "eth-tx-prepare";
-var createWorker2 = /* @__PURE__ */ __name$3((connection2, services) => {
+var createWorker2 = /* @__PURE__ */ __name$2((connection2, services) => {
   const bridge = assertEx(services?.bridge, () => "bridge service not provided");
   const stateMap = assertEx(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
   const worker = new Worker(queueName2, async (job) => {
@@ -342565,8 +342272,8 @@ var createWorker2 = /* @__PURE__ */ __name$3((connection2, services) => {
     await job.log(`[${hash}] building ETH transaction`);
     const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => "No bridge intent found");
     const amount = hexToBigInt(bridgeIntent.destAmount);
-    const srcAddress = getAddress$2(bridgeIntent.srcAddress);
-    const destAddress = getAddress$2(bridgeIntent.destAddress);
+    const srcAddress = getAddress(bridgeIntent.srcAddress);
+    const destAddress = getAddress(bridgeIntent.destAddress);
     const nonce = hexToBigInt(await PayloadBuilder.hash(tx[0]));
     const preparedTx = await bridge.getFunction("bridgeFromRemote").populateTransaction(srcAddress, destAddress, amount, nonce);
     await job.log(`[${hash}] built ETH transaction`);
@@ -342592,7 +342299,7 @@ var EthTransactionPreparation = {
   name: name2,
   queueName: queueName2
 };
-var submitEthTransaction = /* @__PURE__ */ __name$3(async (tx, bridgeableToken, bridge, wallet) => {
+var submitEthTransaction = /* @__PURE__ */ __name$2(async (tx, bridgeableToken, bridge, wallet) => {
   const xl1Transaction = assertEx(tx[0], () => "No corresponding XL1 transaction found");
   const bridgeIntent = assertEx(tx[1].find(isBridgeIntent), () => "No bridge intent found");
   const srcAddress = toEthAddress(bridgeIntent.srcAddress);
@@ -342603,17 +342310,19 @@ var submitEthTransaction = /* @__PURE__ */ __name$3(async (tx, bridgeableToken,
   const receipt = await bridgeTx.wait(1);
   return receipt?.hash;
 }, "submitEthTransaction");
-var submitXl1Transaction = /* @__PURE__ */ __name$3(async (preparedTx, gateway) => {
-  const onChain = preparedTx[1].filter(isAllowedBlockPayload);
-  const offChainPayloads = preparedTx[1].filter((p) => !isAllowedBlockPayload(p));
-  const result = await gateway.addPayloadsToChain(onChain, offChainPayloads);
-  return result;
+var submitXl1Transaction = /* @__PURE__ */ __name$2(async (preparedTx, gateway) => {
+  const runner = assertEx(gateway.connection.runner, () => "No runner available on gateway connection");
+  const result = await runner.broadcastTransaction(preparedTx);
+  return [
+    result,
+    preparedTx
+  ];
 }, "submitXl1Transaction");
 
 // src/queue/workers/EthTransactionSubmission.ts
 var name3 = "Submit ETH Transaction";
 var queueName3 = "eth-tx-submit";
-var createWorker3 = /* @__PURE__ */ __name$3((connection2, services) => {
+var createWorker3 = /* @__PURE__ */ __name$2((connection2, services) => {
   const bridge = assertEx(services?.bridge, () => "bridge service not provided");
   const bridgeableToken = assertEx(services?.bridgeableToken, () => "bridgeableToken service not provided");
   const wallet = assertEx(services?.wallet, () => "wallet service not provided");
@@ -342658,7 +342367,7 @@ var EthTransactionSubmission = {
 };
 var name4 = "Bridge XL1 to Ethereum";
 var queueName4 = "xl1-to-eth-bridge";
-var createWorker4 = /* @__PURE__ */ __name$3((connection2) => {
+var createWorker4 = /* @__PURE__ */ __name$2((connection2) => {
   const worker = new Worker(queueName4, async (job) => {
     await job.log(`[${job.name}] start`);
     await job.log(`[${job.name}] done`);
@@ -342682,7 +342391,7 @@ var Xl1ToEthBridgeParent = {
 };
 var name5 = "Monitor Submitted XL1 Transaction";
 var queueName5 = "xl1-tx-monitor";
-var createWorker5 = /* @__PURE__ */ __name$3((connection2, services) => {
+var createWorker5 = /* @__PURE__ */ __name$2((connection2, services) => {
   const gateway = assertEx(services?.gateway, () => "gateway service not provided");
   const stateMap = assertEx(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
   const worker = new Worker(queueName5, async (job) => {
@@ -342723,7 +342432,7 @@ var Xl1TransactionMonitor = {
 };
 var name6 = "Prepare XL1 Transaction";
 var queueName6 = "xl1-tx-prepare";
-var createWorker6 = /* @__PURE__ */ __name$3((connection2, services) => {
+var createWorker6 = /* @__PURE__ */ __name$2((connection2, services) => {
   const stateMap = assertEx(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
   const worker = new Worker(queueName6, async (job) => {
     const { tx } = job.data;
@@ -342754,7 +342463,7 @@ var Xl1TransactionPreparation = {
 };
 var name7 = "Submit XL1 Transaction";
 var queueName7 = "xl1-tx-submit";
-var createWorker7 = /* @__PURE__ */ __name$3((connection2, services) => {
+var createWorker7 = /* @__PURE__ */ __name$2((connection2, services) => {
   const gateway = assertEx(services?.gateway, () => "gateway service not provided");
   const stateMap = assertEx(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
   const worker = new Worker(queueName7, async (job) => {
@@ -342796,7 +342505,7 @@ var Xl1TransactionSubmission = {
 };
 
 // src/queue/flows/createXl1ToEthBridgeJob.ts
-var createXl1ToEthBridgeJob = /* @__PURE__ */ __name$3(async (flowProducer2, tx) => {
+var createXl1ToEthBridgeJob = /* @__PURE__ */ __name$2(async (flowProducer2, tx) => {
   const flow = await flowProducer2.add({
     name: Xl1ToEthBridgeParent.name,
     queueName: Xl1ToEthBridgeParent.queueName,
@@ -342882,13 +342591,13 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name$3(async (flowProducer2, tx)
 }, "createXl1ToEthBridgeJob");
 
 // src/server/addFlowProducer.ts
-var addFlowProducer = /* @__PURE__ */ __name$3((app, config) => {
+var addFlowProducer = /* @__PURE__ */ __name$2((app, config) => {
   const connection2 = getConnection(config);
   const flowProducer2 = getFlowProducer(connection2);
   app.flowProducer = flowProducer2;
   return app;
 }, "addFlowProducer");
-var addInstrumentation$2 = /* @__PURE__ */ __name$3(() => {
+var addInstrumentation$1 = /* @__PURE__ */ __name$2(() => {
   const instrumentations = [
     new HttpInstrumentation(),
     new ExpressInstrumentation()
@@ -342897,25 +342606,25 @@ var addInstrumentation$2 = /* @__PURE__ */ __name$3(() => {
     instrumentations
   });
 }, "addInstrumentation");
-var asChainId = /* @__PURE__ */ __name$3((value) => {
+var asChainId = /* @__PURE__ */ __name$2((value) => {
   const chainId = asHex(value);
   return chainId;
 }, "asChainId");
-var asToken = /* @__PURE__ */ __name$3((value) => {
+var asToken = /* @__PURE__ */ __name$2((value) => {
   const token = asAddress(value);
   return token;
 }, "asToken");
-var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name$3((config) => {
+var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name$2((config) => {
   const address = asAddress(config.actors.bridge.escrowAddress);
   return address;
 }, "tryGetBridgeEscrowAddress");
-var tryGetBridgeFeesAddress = /* @__PURE__ */ __name$3((config) => {
+var tryGetBridgeFeesAddress = /* @__PURE__ */ __name$2((config) => {
   const address = asAddress(config.actors.bridge.feesAddress);
   return address;
 }, "tryGetBridgeFeesAddress");
 
 // src/config/getFeeStructure.ts
-var getFeeStructure = /* @__PURE__ */ __name$3((config) => {
+var getFeeStructure = /* @__PURE__ */ __name$2((config) => {
   const { feeFixed, feeRateBasisPoints } = config.actors.bridge;
   return {
     feeFixed,
@@ -342924,26 +342633,26 @@ var getFeeStructure = /* @__PURE__ */ __name$3((config) => {
 }, "getFeeStructure");
 
 // src/config/getMaxBridgeAmount.ts
-var getMaxBridgeAmount = /* @__PURE__ */ __name$3((config) => {
+var getMaxBridgeAmount = /* @__PURE__ */ __name$2((config) => {
   const { maxBridgeAmount } = config.actors.bridge;
   return maxBridgeAmount;
 }, "getMaxBridgeAmount");
 
 // src/config/getMinBridgeAmount.ts
-var getMinBridgeAmount = /* @__PURE__ */ __name$3((config) => {
+var getMinBridgeAmount = /* @__PURE__ */ __name$2((config) => {
   const { minBridgeAmount } = config.actors.bridge;
   return minBridgeAmount;
 }, "getMinBridgeAmount");
-var getRemoteChainId = /* @__PURE__ */ __name$3((config) => {
+var getRemoteChainId = /* @__PURE__ */ __name$2((config) => {
   const remoteChainId = assertEx(asChainId(config.actors.bridge.remoteChainId), () => "Invalid remote chain ID in config");
   return remoteChainId;
 }, "getRemoteChainId");
-var getRemoteTokenAddress = /* @__PURE__ */ __name$3((config) => {
+var getRemoteTokenAddress = /* @__PURE__ */ __name$2((config) => {
   const token = asToken(config.actors.bridge.remoteTokenAddress);
   return assertEx(token, () => "Remote token address is not defined in bridge configuration");
 }, "getRemoteTokenAddress");
 var accountServiceSingleton;
-var getBridgeWalletAccount = /* @__PURE__ */ __name$3(async (config) => {
+var getBridgeWalletAccount = /* @__PURE__ */ __name$2(async (config) => {
   if (accountServiceSingleton) return accountServiceSingleton;
   let walletPhrase = config.actors.bridge.mnemonic;
   if (isUndefined$1(walletPhrase)) {
@@ -342963,7 +342672,7 @@ ${randomMnemonic}
 }, "getBridgeWalletAccount");
 
 // src/config/getTransferAddresses.ts
-var getTransferAddresses = /* @__PURE__ */ __name$3(async (config) => {
+var getTransferAddresses = /* @__PURE__ */ __name$2(async (config) => {
   const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
   const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
   return {
@@ -342971,21 +342680,21 @@ var getTransferAddresses = /* @__PURE__ */ __name$3(async (config) => {
     feesAddress
   };
 }, "getTransferAddresses");
-var getXl1ChainId = /* @__PURE__ */ __name$3((config) => {
+var getXl1ChainId = /* @__PURE__ */ __name$2((config) => {
   const xl1ChainId = config.actors.bridge.xl1ChainId;
   if (isDefined(xl1ChainId)) {
     return assertEx(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
   }
   return assertEx(asChainId(config.chain.id), () => "Invalid chain.id in config");
 }, "getXl1ChainId");
-var getXl1TokenAddress = /* @__PURE__ */ __name$3((config) => {
+var getXl1TokenAddress = /* @__PURE__ */ __name$2((config) => {
   const token = asToken(config.actors.bridge.xl1TokenAddress);
   if (isDefined(token)) return token;
   return getXl1ChainId(config);
 }, "getXl1TokenAddress");
 
 // src/config/getBridgeSettings.ts
-var getBridgeSettings = /* @__PURE__ */ __name$3(async (config) => {
+var getBridgeSettings = /* @__PURE__ */ __name$2(async (config) => {
   const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
   const { feesAddress, escrowAddress } = await getTransferAddresses(config);
   const maxBridgeAmount = getMaxBridgeAmount(config);
@@ -343007,27 +342716,13 @@ var getBridgeSettings = /* @__PURE__ */ __name$3(async (config) => {
     xl1ChainId
   };
 }, "getBridgeSettings");
-var gatewayInstance;
-var getGateway$1 = /* @__PURE__ */ __name$3(async (config) => {
-  if (isDefined(gatewayInstance)) return gatewayInstance;
-  const { mnemonic, chainRpcApiUrl: endpoint } = config.actors.bridge;
-  const walletPhrase = isDefined(mnemonic) ? mnemonic : HDWallet.generateMnemonic();
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
-  const signerAccount = await wallet.derivePath(ADDRESS_INDEX.XYO);
-  const transportFactory = /* @__PURE__ */ __name$3((schemas) => new HttpRpcTransport(endpoint, schemas), "transportFactory");
-  const locator = await buildJsonRpcProviderLocator({
-    transportFactory,
-    signerAccount
-  });
-  return await locator.getInstance(XyoGatewayRunnerMoniker);
-}, "getGateway");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 var BridgeConfigResponseZod = BridgeSettingsZod;
 var validateRequest$1 = requestHandlerValidator({
   response: BridgeConfigResponseZod
 });
-var makeBridgeConfigRoute = /* @__PURE__ */ __name$3((config) => {
+var makeBridgeConfigRoute = /* @__PURE__ */ __name$2((config) => {
   return {
     method: "get",
     path: "/bridge/chains/:chainId/config",
@@ -343049,7 +342744,7 @@ var makeBridgeConfigRoute = /* @__PURE__ */ __name$3((config) => {
     })
   };
 }, "makeBridgeConfigRoute");
-var getRemoteChainIdZod = /* @__PURE__ */ __name$3((config) => {
+var getRemoteChainIdZod = /* @__PURE__ */ __name$2((config) => {
   const remoteChainId = getRemoteChainId(config);
   return HexZod.superRefine((val, ctx) => {
     const chainId = asHex(val);
@@ -343064,7 +342759,7 @@ var getRemoteChainIdZod = /* @__PURE__ */ __name$3((config) => {
 }, "getRemoteChainIdZod");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
-var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name$3((config) => {
+var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name$2((config) => {
   const params = object$4({
     chainId: getRemoteChainIdZod(config),
     nonce: string$2().nonempty()
@@ -343100,7 +342795,7 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name$3((config) => {
     })
   };
 }, "makeBridgeFromRemoteStatusRoute");
-var calculateBridgeFees = /* @__PURE__ */ __name$3((srcAmount, feeStructure) => {
+var calculateBridgeFees = /* @__PURE__ */ __name$2((srcAmount, feeStructure) => {
   const { feeFixed, feeRateBasisPoints } = feeStructure;
   const srcAmountBigInt = hexToBigInt(srcAmount);
   const feeFixedBigInt = hexToBigInt(feeFixed);
@@ -343115,7 +342810,7 @@ var calculateBridgeFees = /* @__PURE__ */ __name$3((srcAmount, feeStructure) =>
     feeVariable
   };
 }, "calculateBridgeFees");
-var generateBridgeEstimate = /* @__PURE__ */ __name$3(async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
+var generateBridgeEstimate = /* @__PURE__ */ __name$2(async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
   const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
   const sender = toAddress(srcAddress);
   const fees = calculateBridgeFees(srcAmount, {
@@ -343154,7 +342849,7 @@ var generateBridgeEstimate = /* @__PURE__ */ __name$3(async (srcAddress, srcAmou
     transfer
   ];
 }, "generateBridgeEstimate");
-var validateBridgeEstimateExact = /* @__PURE__ */ __name$3(async (intent, transfer, config) => {
+var validateBridgeEstimateExact = /* @__PURE__ */ __name$2(async (intent, transfer, config) => {
   const { srcAddress, srcAmount, destAddress } = intent;
   const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
   if (isUndefined$1(calculatedIntent) || isUndefined$1(calculatedTransfer)) return false;
@@ -343166,7 +342861,7 @@ var validateBridgeEstimateExact = /* @__PURE__ */ __name$3(async (intent, transf
   if (await PayloadBuilder.dataHash(expectedTransferStatic) !== await PayloadBuilder.dataHash(actualTransferStatic)) return false;
   return true;
 }, "validateBridgeEstimateExact");
-var validateBridgeTransaction = /* @__PURE__ */ __name$3(async (signedTxBw, intent, transfer, config) => {
+var validateBridgeTransaction = /* @__PURE__ */ __name$2(async (signedTxBw, intent, transfer, config) => {
   const { srcAddress } = intent;
   const chainId = getXl1ChainId(config);
   if (signedTxBw.chain !== chainId) return false;
@@ -343189,7 +342884,7 @@ var BridgeToRemoteBodyZod = tuple([
   TransferZod
 ]);
 var BridgeToRemoteResponseZod = PayloadZodStrictOfSchema(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape);
-var makeBridgeToRemoteRoute = /* @__PURE__ */ __name$3((config) => {
+var makeBridgeToRemoteRoute = /* @__PURE__ */ __name$2((config) => {
   const params = object$4({
     chainId: getRemoteChainIdZod(config)
   });
@@ -343246,7 +342941,7 @@ var BridgeToRemoteEstimateResponseZod = tuple([
   PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
   TransferZod
 ]);
-var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name$3((config) => {
+var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name$2((config, gateway) => {
   const params = object$4({
     chainId: getRemoteChainIdZod(config)
   });
@@ -343263,7 +342958,6 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name$3((config) => {
       const { srcAddress, srcAmount, destAddress } = req.body;
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
       const sender = toAddress(srcAddress);
-      const gateway = await getGateway$1(config);
       const viewer = assertEx(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
       const currentBlockNumber = await viewer.currentBlockNumber();
       const nbf = toXL1BlockNumber(currentBlockNumber, true);
@@ -343296,7 +342990,7 @@ var BridgeToRemoteStatusResponseZod = union$1([
     PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape)
   ])
 ]);
-var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name$3((config) => {
+var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name$2((config) => {
   const params = object$4({
     chainId: getRemoteChainIdZod(config),
     nonce: string$2().nonempty()
@@ -343366,10 +343060,10 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name$3((config) => {
 }, "makeBridgeToRemoteStatusRoute");
 
 // src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts
-var getRouteDefinitions$1 = /* @__PURE__ */ __name$3((config) => {
+var getRouteDefinitions$1 = /* @__PURE__ */ __name$2((config, gateway) => {
   return [
     makeBridgeConfigRoute(config),
-    makeBridgeToRemoteEstimateRoute(config),
+    makeBridgeToRemoteEstimateRoute(config, gateway),
     makeBridgeToRemoteRoute(config),
     makeBridgeToRemoteStatusRoute(config),
     makeBridgeFromRemoteStatusRoute(config)
@@ -343377,21 +343071,21 @@ var getRouteDefinitions$1 = /* @__PURE__ */ __name$3((config) => {
 }, "getRouteDefinitions");
 
 // src/server/routes/bridge/addBridgeRoutes.ts
-var addBridgeRoutes = /* @__PURE__ */ __name$3((app, config) => {
-  const routeDefinitions = getRouteDefinitions$1(config);
+var addBridgeRoutes = /* @__PURE__ */ __name$2((app, config, gateway) => {
+  const routeDefinitions = getRouteDefinitions$1(config, gateway);
   for (const definition of routeDefinitions) {
     app[definition.method](definition.path, definition.handlers);
   }
 }, "addBridgeRoutes");
 
 // src/server/routes/addRoutes.ts
-var addRoutes$2 = /* @__PURE__ */ __name$3((app, config) => {
-  addBridgeRoutes(app, config);
+var addRoutes$1 = /* @__PURE__ */ __name$2((app, config, gateway) => {
+  addBridgeRoutes(app, config, gateway);
 }, "addRoutes");
 
 // src/server/app.ts
-var getApp$2 = /* @__PURE__ */ __name$3((node, config) => {
-  addInstrumentation$2();
+var getApp$1 = /* @__PURE__ */ __name$2((node, config, gateway) => {
+  addInstrumentation$1();
   const app = express2();
   app.set("etag", false);
   app.use(cors());
@@ -343406,7 +343100,7 @@ var getApp$2 = /* @__PURE__ */ __name$3((node, config) => {
   disableCaseSensitiveRouting(app);
   app.node = node;
   addFlowProducer(app, config);
-  addRoutes$2(app, config);
+  addRoutes$1(app, config, gateway);
   app.use(standardErrors);
   return app;
 }, "getApp");
@@ -343414,7 +343108,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema = asSchem
 var defaultJobCheckIntervalMs = 15e3;
 var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends AbstractSentinel {
   static {
-    __name$3(this, "EVMLiquidityBridgeTransactionCompletionMonitorSentinel");
+    __name$2(this, "EVMLiquidityBridgeTransactionCompletionMonitorSentinel");
   }
   static configSchemas = [
     EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
@@ -343462,7 +343156,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
     const { provider, bridgeAddress } = this.params;
     const key = assertEx(this.account?.private?.hex, () => new Error("Account private key is required"));
     this._wallet = new Wallet(key, provider);
-    this._bridge = LiquidityPoolBridge__factory.connect(getAddress$2(bridgeAddress), this._wallet);
+    this._bridge = LiquidityPoolBridge__factory.connect(getAddress(bridgeAddress), this._wallet);
     const network = await provider.getNetwork();
     this._bridgeChainId = assertEx(hexFromBigInt(network.chainId), () => new Error("Failed to parse bridgeChainId"));
     const tokenAddress = await this.bridge.token();
@@ -343536,8 +343230,8 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
   async relayBridgeIntentSync(bridgeIntent) {
     const amount = hexToBigInt(bridgeIntent.destAmount);
     const nonce = await this.wallet.getNonce();
-    const srcAddress = getAddress$2(bridgeIntent.srcAddress);
-    const destAddress = getAddress$2(bridgeIntent.destAddress);
+    const srcAddress = getAddress(bridgeIntent.srcAddress);
+    const destAddress = getAddress(bridgeIntent.destAddress);
     const tx = await this.bridge.bridgeFromRemote(srcAddress, destAddress, amount, nonce);
     const confirmation = await tx.wait();
     const transactionResponse = await confirmation?.getTransaction();
@@ -343556,7 +343250,7 @@ var XL1TransactionCompletionMonitorSentinelConfigSchema = asSchema("network.xyo.
 var defaultJobCheckIntervalMs2 = 15e3;
 var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel {
   static {
-    __name$3(this, "XL1TransactionCompletionMonitorSentinel");
+    __name$2(this, "XL1TransactionCompletionMonitorSentinel");
   }
   static configSchemas = [
     XL1TransactionCompletionMonitorSentinelConfigSchema
@@ -343663,7 +343357,7 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel {
 };
 
 // src/manifest/getModuleLocator.ts
-var getModuleLocator = /* @__PURE__ */ __name$3(async (context) => {
+var getModuleLocator = /* @__PURE__ */ __name$2(async (context) => {
   const { config, locator, logger } = context;
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = 9468 } = config.telemetry?.metrics?.scrape ?? {};
@@ -343750,7 +343444,7 @@ var getModuleLocator = /* @__PURE__ */ __name$3(async (context) => {
   moduleLocator.register(EVMLiquidityBridgeTransactionCompletionMonitorSentinel.factory(evmLiquidityBridgeTransactionCompletionMonitorSentinelParams));
   return moduleLocator;
 }, "getModuleLocator");
-var getIterableMap = /* @__PURE__ */ __name$3(async (config, collection) => {
+var getIterableMap = /* @__PURE__ */ __name$2(async (config, collection) => {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
     const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
@@ -343801,10 +343495,10 @@ var node_default$1 = {
 var NodeManifest$1 = node_default$1;
 
 // src/manifest/getNode.ts
-var getNode$1 = /* @__PURE__ */ __name$3(async (context) => {
+var getNode$1 = /* @__PURE__ */ __name$2(async (context) => {
   const { config, wallet } = context;
   const { chainRpcApiUrl: endpoint } = config.actors.bridge;
-  const transportFactory = /* @__PURE__ */ __name$3((schemas) => new HttpRpcTransport(endpoint, schemas), "transportFactory");
+  const transportFactory = /* @__PURE__ */ __name$2((schemas) => new HttpRpcTransport(endpoint, schemas), "transportFactory");
   const signerAccount = await getBridgeWalletAccount(config);
   const locator = await buildJsonRpcProviderLocator({
     signerAccount,
@@ -343822,7 +343516,7 @@ var getNode$1 = /* @__PURE__ */ __name$3(async (context) => {
   }
   return node;
 }, "getNode");
-var getIterableMap2 = /* @__PURE__ */ __name$3(async (config, collection) => {
+var getIterableMap2 = /* @__PURE__ */ __name$2(async (config, collection) => {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
     const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
@@ -343851,9 +343545,8 @@ var getIterableMap2 = /* @__PURE__ */ __name$3(async (config, collection) => {
 }, "getIterableMap");
 
 // src/manifest/getServices.ts
-var getServices = /* @__PURE__ */ __name$3(async (context) => {
+var getServices = /* @__PURE__ */ __name$2(async (context, gateway) => {
   const { config } = context;
-  const gateway = await getGateway$1(config);
   const ethTxStateMap = await getIterableMap2(config, "liquidity_bridge_xl1_to_eth_eth_tx_state");
   const xl1TxStateMap = await getIterableMap2(config, "liquidity_bridge_xl1_to_eth_xl1_tx_state");
   const provider = await initEvmProvider({
@@ -343862,8 +343555,8 @@ var getServices = /* @__PURE__ */ __name$3(async (context) => {
   const { remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, mnemonic } = config.actors.bridge;
   const account = isDefined(mnemonic) ? await HDWallet.fromPhrase(mnemonic) : await HDWallet.random();
   const wallet = new Wallet(remoteChainWalletPrivateKey, provider);
-  const bridgeableToken = BridgeableToken__factory.connect(getAddress$2(remoteTokenAddress), wallet);
-  const bridge = LiquidityPoolBridge__factory.connect(getAddress$2(remoteBridgeContractAddress), wallet);
+  const bridgeableToken = BridgeableToken__factory.connect(getAddress(remoteTokenAddress), wallet);
+  const bridge = LiquidityPoolBridge__factory.connect(getAddress(remoteBridgeContractAddress), wallet);
   const bridgeOwner = await bridge.owner();
   assertEx(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
   return {
@@ -343879,14 +343572,14 @@ var getServices = /* @__PURE__ */ __name$3(async (context) => {
 }, "getServices");
 
 // src/server/addWorkers.ts
-var addWorkers = /* @__PURE__ */ __name$3((config, services) => {
+var addWorkers = /* @__PURE__ */ __name$2((config, services) => {
   const connection2 = getConnection(config);
   createWorkers(connection2, services);
 }, "addWorkers");
 
 // src/server/server.ts
-var hostname$2 = "::";
-var getSeedPhrase$1 = /* @__PURE__ */ __name$3(async (bios, config, logger) => {
+var hostname$1 = "::";
+var getSeedPhrase$1 = /* @__PURE__ */ __name$2(async (bios, config, logger) => {
   const storedSeedPhrase = await bios.seedPhraseStore.get("os");
   logger?.debug(`[Bridge] Stored mnemonic: ${storedSeedPhrase}`);
   const { mnemonic } = config.actors.api;
@@ -343906,7 +343599,7 @@ var getSeedPhrase$1 = /* @__PURE__ */ __name$3(async (bios, config, logger) => {
   }
   return assertEx(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }, "getSeedPhrase");
-var getServer$2 = /* @__PURE__ */ __name$3(async (context) => {
+var getServer$1 = /* @__PURE__ */ __name$2(async (context, gateway) => {
   const { logger, config } = context;
   const { port, mnemonic } = config.actors.bridge;
   const bios = await boot();
@@ -343918,369 +343611,58 @@ var getServer$2 = /* @__PURE__ */ __name$3(async (context) => {
     config
   };
   const node = context.node ?? await getNode$1(nodeContext);
-  const app = getApp$2(node, config);
+  const app = getApp$1(node, config, gateway);
   const services = await getServices({
     config,
     logger
-  });
+  }, gateway);
   addWorkers(config, services);
-  const server = app.listen(port, hostname$2, () => logger?.log(`[Bridge] Server listening at http://${hostname$2}:${port}`));
+  const server = app.listen(port, hostname$1, () => logger?.log(`[Bridge] Server listening at http://${hostname$1}:${port}`));
   server.setTimeout(2e4);
   return server;
 }, "getServer");
 
-var __defProp$2 = Object.defineProperty;
-var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
-var addInstrumentation$1 = /* @__PURE__ */ __name$2(() => {
-  const instrumentations = [
-    new HttpInstrumentation(),
-    new ExpressInstrumentation()
-  ];
-  registerInstrumentations({
-    instrumentations
-  });
-}, "addInstrumentation");
-var handler = /* @__PURE__ */ __name$2(async (req, res, next) => {
-  const { address: moduleIdentifier } = req.params;
-  const { node } = req.app;
-  const address = asAddress(moduleIdentifier);
-  if (isDefined(address)) {
-    let mod = node.address === address ? node : await node.resolve(address, {
-      direction: "down"
-    });
-    if (mod) {
-      res.json(await mod.state());
-      return;
-    }
+// src/BridgeActor.ts
+function _ts_decorate$1(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$2(_ts_decorate$1, "_ts_decorate");
+var BridgeActor = class extends ActorV3 {
+  static {
+    __name$2(this, "BridgeActor");
   }
-  if (isModuleName(moduleIdentifier)) {
-    const mod = await node.resolve(moduleIdentifier, {
-      direction: "down"
-    });
-    if (mod) {
-      res.redirect(StatusCodes.MOVED_TEMPORARILY, `/${mod.address}`);
-      return;
-    }
+  _gatewayRunner;
+  server;
+  get gatewayRunner() {
+    return this._gatewayRunner;
   }
-  next("route");
-}, "handler");
-var getAddress = asyncHandler(handler);
-var DEFAULT_DEPTH = 5;
-var getQueryConfig = /* @__PURE__ */ __name$2((mod, req, bw, payloads) => {
-  const nestedBwAddresses = payloads?.flat(DEFAULT_DEPTH).filter((payload) => payload?.schema === BoundWitnessSchema).map((bw2) => bw2.addresses) ?? [];
-  const addresses = [
-    bw.addresses,
-    ...nestedBwAddresses
-  ].filter((address) => address.length > 0);
-  const allowed = addresses.length > 0 ? Object.fromEntries(mod.queries.map((schema) => [
-    schema,
-    addresses
-  ])) : {};
-  const security = {
-    allowed
-  };
-  return {
-    schema: ModuleConfigSchema,
-    security
-  };
-}, "getQueryConfig");
-
-// src/server/routes/address/post/post.ts
-var handler2 = /* @__PURE__ */ __name$2(async (req, res, next) => {
-  const returnError = /* @__PURE__ */ __name$2((code, message = "An error occurred", details) => {
-    const error = new ModuleErrorBuilder().message(message).details(details).build();
-    res.locals.rawResponse = false;
-    res.status(code).json(error);
-    next();
-  }, "returnError");
-  const { address } = req.params;
-  const { node } = req.app;
-  const [bw, payloads] = Array.isArray(req.body) ? req.body : [];
-  if (!isAddress(address)) {
-    return returnError(StatusCodes.BAD_REQUEST, "Missing address");
-  }
-  if (!bw) {
-    return returnError(StatusCodes.BAD_REQUEST, "Missing boundwitness");
-  }
-  if (!isQueryBoundWitness(bw)) {
-    return returnError(StatusCodes.BAD_REQUEST, "Invalid query boundwitness");
-  }
-  let modules = [];
-  const normalizedAddress = toAddress(address);
-  if (node.address === normalizedAddress) modules = [
-    node
-  ];
-  else {
-    const typedAddress = asAddress(address);
-    const byAddress = typedAddress === void 0 ? void 0 : await node.resolve(typedAddress, {
-      maxDepth: 10
-    });
-    if (byAddress) modules = [
-      byAddress
-    ];
-    else {
-      const byName = await node.resolve(address, {
-        direction: "down"
-      });
-      if (byName) {
-        const moduleAddress = assertEx(byName?.address, () => "Error redirecting to module by address");
-        res.redirect(StatusCodes.TEMPORARY_REDIRECT, `/${moduleAddress}`);
-        return;
-      } else {
-        return returnError(StatusCodes.NOT_FOUND, "Module not found", {
-          address
-        });
-      }
-    }
+  async createHandler() {
+    await super.createHandler();
+    this._gatewayRunner = await this.locator.getInstance(XyoGatewayRunnerMoniker);
   }
-  if (modules.length > 0) {
-    const mod = modules[0];
-    const queryConfig = getQueryConfig(mod, req, bw, payloads);
-    try {
-      const queryResult = await mod.query(bw, payloads, queryConfig);
-      res.json(queryResult);
-    } catch (ex) {
-      return returnError(StatusCodes.INTERNAL_SERVER_ERROR, "Query Failed", {
-        message: ex?.message ?? "Unknown Error"
-      });
-    }
-  } else {
-    return returnError(StatusCodes.NOT_FOUND, "Module not found", {
-      address
-    });
+  async startHandler() {
+    await super.startHandler();
+    this.stopServer();
+    await this.startServer();
   }
-}, "handler");
-var postAddress = asyncHandler(handler2);
-
-// src/server/routes/address/addNodeRoutes.ts
-var addNodeRoutes = /* @__PURE__ */ __name$2((app) => {
-  const defaultModule = app.node;
-  const address = defaultModule.address;
-  const defaultModuleEndpoint = `/${address}`;
-  app.get("/", (_req, res) => res.redirect(StatusCodes.MOVED_TEMPORARILY, defaultModuleEndpoint));
-  app.post("/", (_req, res) => res.redirect(StatusCodes.TEMPORARY_REDIRECT, defaultModuleEndpoint));
-  app.get("/:address", getAddress);
-  app.post("/:address", postAddress);
-  app.get("/:hash", (_req, res) => {
-    res.sendStatus(StatusCodes.NOT_FOUND);
-  });
-  app.post("/:hash", (_req, res) => {
-    res.sendStatus(StatusCodes.NOT_FOUND);
-  });
-}, "addNodeRoutes");
-var resolveArchivist$1 = /* @__PURE__ */ __name$2(async (node, archivistModuleIdentifier) => {
-  const mod = await node.resolve(archivistModuleIdentifier);
-  return asArchivistInstance(mod, {
-    required: true
-  });
-}, "resolveArchivist");
-var archivistInstance$1;
-var getArchivist$1 = /* @__PURE__ */ __name$2(async (node, archivistModuleIdentifier) => {
-  if (isDefined(archivistInstance$1)) return archivistInstance$1;
-  archivistInstance$1 = await resolveArchivist$1(node, archivistModuleIdentifier);
-  return archivistInstance$1;
-}, "getArchivist");
-var archivistMiddleware$1 = /* @__PURE__ */ __name$2((options) => {
-  const { node, archivistModuleIdentifier } = options;
-  const router = express2.Router({
-    mergeParams: true
-  });
-  router.post("/insert", async (req, res) => {
-    setRawResponseFormat(res);
-    const body = Array.isArray(req.body) ? req.body : [
-      req.body
-    ];
-    const payloads = (await PayloadBuilder.hashPairs(body)).map((p) => p[0]);
-    const archivist = await getArchivist$1(node, archivistModuleIdentifier);
-    const result = await archivist.insert(payloads);
-    res.status(200).json(result);
-  });
-  router.get("/next", async (req, res) => {
-    setRawResponseFormat(res);
-    const cursor = isSequence(req.query.cursor) ? req.query.cursor : void 0;
-    const limit = isDefined(req.query.limit) ? Number(req.query.limit) : void 0;
-    const open = isDefined(req.query.open) ? Boolean(req.query.open) : void 0;
-    const order = req.query.order === "asc" ? "asc" : "desc";
-    const options2 = {
-      limit,
-      open,
-      order,
-      cursor
-    };
-    const archivist = await getArchivist$1(node, archivistModuleIdentifier);
-    const result = await archivist.next(options2);
-    res.status(200).json(result);
-  });
-  router.post("/next", async (req, res) => {
-    setRawResponseFormat(res);
-    const options2 = req.body;
-    const archivist = await getArchivist$1(node, archivistModuleIdentifier);
-    const result = await (isDefined(options2) ? archivist.next(options2) : archivist.next());
-    res.status(200).json(result);
-  });
-  router.get("/get/:hash", async (req, res) => {
-    setRawResponseFormat(res);
-    const { hash: rawHash } = req.params;
-    const hash = asHash(rawHash);
-    if (isDefined(hash)) {
-      const archivist = await getArchivist$1(node, archivistModuleIdentifier);
-      const [payload] = await archivist.get([
-        hash
-      ]);
-      if (isAnyPayload(payload)) {
-        res.json(payload);
-        return;
-      }
-    }
-    res.status(400).send();
-  });
-  return router;
-}, "archivistMiddleware");
-
-// src/server/routes/dataLake/addDataLakeRoutes.ts
-var addDataLakeRoutes$1 = /* @__PURE__ */ __name$2((app) => {
-  const { node } = app;
-  const archivistModuleIdentifier = "Chain:Finalized";
-  app.use("/chain", archivistMiddleware$1({
-    node,
-    archivistModuleIdentifier
-  }));
-}, "addDataLakeRoutes");
-var addHealthRoutes = /* @__PURE__ */ __name$2((app) => {
-  app.get("/healthz", (_req, res) => {
-    res.status(StatusCodes.OK).send();
-  });
-  app.get("/livez", (_req, res) => {
-    res.status(StatusCodes.OK).send();
-  });
-  app.get("/readyz", (_req, res) => {
-    res.status(StatusCodes.OK).send();
-  });
-}, "addHealthRoutes");
-
-// src/server/routes/addRoutes.ts
-var addRoutes$1 = /* @__PURE__ */ __name$2((app) => {
-  addHealthRoutes(app);
-  addDataLakeRoutes$1(app);
-  addNodeRoutes(app);
-}, "addRoutes");
-
-// src/server/app.ts
-var getApp$1 = /* @__PURE__ */ __name$2((context) => {
-  addInstrumentation$1();
-  const app = express2();
-  app.set("etag", false);
-  app.use(cors());
-  app.use(compression$1());
-  app.use(responseProfiler);
-  app.use(getJsonBodyParser(getJsonBodyParserOptions({
-    limit: "1mb"
-  })));
-  app.use(standardResponses);
-  disableExpressDefaultPoweredByHeader(app);
-  app.use(customPoweredByHeader);
-  disableCaseSensitiveRouting(app);
-  app.context = context;
-  app.node = context.node;
-  addRoutes$1(app);
-  app.use(standardErrors);
-  return app;
-}, "getApp");
-var hostname$1 = "::";
-var getProviderFactoryLocator = /* @__PURE__ */ __name$2((context, finalizedArchivist, pendingTransactionsArchivist, pendingBlocksArchivist) => {
-  const locator = new ProviderFactoryLocator(context);
-  locator.register(SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
-    state: validateHydratedBlockState,
-    protocol: validateHydratedBlock
-  }));
-  locator.register(SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
-    pendingTransactionsArchivist,
-    pendingBlocksArchivist
-  }));
-  locator.register(SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
-    pendingTransactionsArchivist,
-    pendingBlocksArchivist
-  }));
-  locator.register(SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, {
-    finalizedArchivist
-  }));
-  locator.register(SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
-    maxWindowSize: 1e4,
-    syncInterval: 1e4
-  }));
-  locator.register(SimpleStakeViewer.factory(SimpleStakeViewer.dependencies, {}));
-  locator.register(SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, {}));
-  return locator;
-}, "getProviderFactoryLocator");
-var getServer$1 = /* @__PURE__ */ __name$2(async (context) => {
-  const { config, node: providedNode } = context;
-  const { port } = context.config.actors.api;
-  const logger = assertEx(context.logger, () => "Logger is required to init server");
-  const statusReporter = initStatusReporter({
-    logger
-  });
-  await startupSpanAsync("initHealthEndpoints", () => initHealthEndpoints({
-    config,
-    logger,
-    statusReporter
-  }));
-  const telemetryConfig = buildTelemetryConfig(config, "xl1-mempool", "1.0.0", DefaultMetricsScrapePorts.mempool);
-  const { traceProvider, meterProvider } = await startupSpanAsync("initTelemetry", () => initTelemetry(telemetryConfig));
-  const initContext = {
-    _id: "init-context",
-    config,
-    logger,
-    statusReporter,
-    meterProvider,
-    traceProvider,
-    singletons: {},
-    caches: {}
-  };
-  const wallet = await initMempoolWallet(initContext);
-  const balancesSummaryMap = assertEx(await initBalanceSummaryMap(initContext), () => "Balance Summary Map not initialized");
-  const transfersSummaryMap = assertEx(await initTransferSummaryMap(initContext), () => "Transfer Summary Map not initialized");
-  const { node, writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist } = await initServerNode({
-    ...initContext,
-    wallet,
-    node: providedNode,
-    transfersSummaryMap,
-    balancesSummaryMap
-  });
-  assertEx(await findMostRecentBlock(readonlyChainArchivist), () => "No head found");
-  const mods = await node.resolve("*");
-  await Promise.all(mods.map((mod) => {
-    return mod.start?.() ?? (() => true);
-  }));
-  const locator = getProviderFactoryLocator(initContext, writableChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist);
-  const mempoolContext = {
-    ...initContext,
-    node,
-    transfersSummaryMap,
-    balancesSummaryMap,
-    ...locator.context,
-    _id: "mempool-context"
-  };
-  const blockViewer = await locator.getInstance(BlockViewerMoniker);
-  assertEx(await blockViewer.start(), () => "Failed to start BlockViewer");
-  const blk = await blockViewer.currentBlock();
-  assertEx(blk, () => "No blocks found after initialization");
-  const mempoolViewer = await locator.getInstance(MempoolViewerMoniker);
-  assertEx(await mempoolViewer.start(), () => "Failed to start MempoolViewer");
-  console.info(`[Mempool] Current block after initialization: #${blk[0].block} (${blk[0]._hash})`);
-  const actor = await ValidatorActor.create({
-    id: "validator-mempool-server",
-    account: wallet,
-    context: locator.context,
-    finalizedArchivist: writableChainArchivist,
-    blockViewer,
-    mempoolViewer
-  });
-  await actor.start();
-  const app = getApp$1(mempoolContext);
-  const server = app.listen(port, hostname$1, () => logger?.log(`[Mempool] Server listening at http://${hostname$1}:${port}`));
-  server.setTimeout(2e4);
-  return server;
-}, "getServer");
+  async stopHandler() {
+    await super.stopHandler();
+    this.stopServer();
+  }
+  async startServer() {
+    this.server = await getServer$1(this.context, this._gatewayRunner);
+  }
+  stopServer() {
+    this.server?.close();
+    this.server = void 0;
+  }
+};
+BridgeActor = _ts_decorate$1([
+  creatable()
+], BridgeActor);
 
 var __defProp$1 = Object.defineProperty;
 var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
@@ -344791,7 +344173,7 @@ var DerivedAddressWalletTransferSentinel = class extends AbstractSentinel {
 };
 
 // src/manifest/getLocator.ts
-var getLocator = /* @__PURE__ */ __name$1(async (context) => {
+var getLocator = /* @__PURE__ */ __name$1(async (context, gateway) => {
   const { config, logger } = context;
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = 9467 } = config.telemetry?.metrics?.scrape ?? {};
@@ -344842,7 +344224,6 @@ var getLocator = /* @__PURE__ */ __name$1(async (context) => {
     meterProvider,
     statusReporter
   }));
-  const gateway = await getGateway(config);
   const chainStepRewardsClaimSentinelParams = {
     gateway,
     traceProvider,
@@ -344859,22 +344240,6 @@ var getLocator = /* @__PURE__ */ __name$1(async (context) => {
   locator.register(DerivedAddressWalletTransferSentinel.factory(derivedAddressWalletTransferSentinelParams));
   return locator;
 }, "getLocator");
-var getGateway = /* @__PURE__ */ __name$1(async (config) => {
-  const { mnemonic, chainRpcApiUrl } = config.actors.rewardRedemption;
-  const transportFactory = /* @__PURE__ */ __name$1((schemas) => new HttpRpcTransport(chainRpcApiUrl, schemas), "transportFactory");
-  const locator = await buildJsonRpcProviderLocator({
-    transportFactory
-  });
-  const phrase = mnemonic ?? HDWallet.generateMnemonic();
-  const wallet = await generateXyoBaseWalletFromPhrase(phrase);
-  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
-  locator.register(SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
-    account
-  }));
-  locator.register(SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {}));
-  const gateway = await locator.getInstance(SimpleXyoGatewayRunner.defaultMoniker);
-  return gateway;
-}, "getGateway");
 
 // src/manifest/node.json
 var node_default = {
@@ -344973,9 +344338,9 @@ var PrivateChildManifests = [];
 var PublicChildManifests = [];
 
 // src/manifest/getNode.ts
-var getNode = /* @__PURE__ */ __name$1(async (context) => {
+var getNode = /* @__PURE__ */ __name$1(async (context, gateway) => {
   const { wallet } = context;
-  const locator = await getLocator(context);
+  const locator = await getLocator(context, gateway);
   const wrapper = new ManifestWrapper(NodeManifest, wallet, locator, PublicChildManifests, PrivateChildManifests);
   const [node, ...childNodes] = await wrapper.loadNodes();
   if (childNodes?.length > 0) {
@@ -345007,7 +344372,7 @@ var getSeedPhrase = /* @__PURE__ */ __name$1(async (bios, config, logger) => {
   }
   return assertEx(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }, "getSeedPhrase");
-var getServer = /* @__PURE__ */ __name$1(async (context) => {
+var getServer = /* @__PURE__ */ __name$1(async (context, gateway) => {
   const { logger, config } = context;
   const { port, mnemonic } = config.actors.rewardRedemption;
   const bios = await boot();
@@ -345018,13 +344383,55 @@ var getServer = /* @__PURE__ */ __name$1(async (context) => {
     logger,
     config
   };
-  const node = context.node ?? await getNode(nodeContext);
+  const node = context.node ?? await getNode(nodeContext, gateway);
   const app = getApp(node, config);
   const server = app.listen(port, hostname, () => logger?.log(`[RewardsRedemption] Server listening at http://${hostname}:${port}`));
   server.setTimeout(12e4);
   return server;
 }, "getServer");
 
+// src/RewardRedemptionActor.ts
+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$1(_ts_decorate, "_ts_decorate");
+var RewardRedemptionActor = class extends ActorV3 {
+  static {
+    __name$1(this, "RewardRedemptionActor");
+  }
+  _gatewayRunner;
+  server;
+  get gatewayRunner() {
+    return this._gatewayRunner;
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._gatewayRunner = await this.locator.getInstance(XyoGatewayRunnerMoniker);
+  }
+  async startHandler() {
+    await super.startHandler();
+    this.stopServer();
+    await this.startServer();
+  }
+  async stopHandler() {
+    await super.stopHandler();
+    this.stopServer();
+  }
+  async startServer() {
+    this.server = await getServer(this.context, this._gatewayRunner);
+  }
+  stopServer() {
+    this.server?.close();
+    this.server = void 0;
+  }
+};
+RewardRedemptionActor = _ts_decorate([
+  creatable()
+], RewardRedemptionActor);
+
 var dist = {};
 
 var defaults = {};
@@ -351881,16 +351288,41 @@ var mainExports = requireMain();
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function runBridge(context) {
-  void getServer$2(context);
-}
-__name(runBridge, "runBridge");
-function runMempool(context) {
-  void getServer$1(context);
-}
-__name(runMempool, "runMempool");
-function runRewardRedemptionApi(context) {
-  void getServer(context);
+var runBridge = /* @__PURE__ */ __name(async (config2, orchestrator, locator) => {
+  const account = await initBridgeWallet({
+    config: config2,
+    logger: locator.context.logger
+  });
+  const api = await BridgeActor.create({
+    account,
+    config: config2,
+    locator
+  });
+  const actors = [
+    api
+  ].filter(exists$2);
+  for (const actor of actors) {
+    await orchestrator.registerActor(actor);
+  }
+  await orchestrator.start();
+}, "runBridge");
+async function runRewardRedemptionApi(config2, orchestrator, locator) {
+  const account = await initRewardsRedemptionApiWallet({
+    config: config2,
+    logger: locator.context.logger
+  });
+  const rewardRedemption = await RewardRedemptionActor.create({
+    account,
+    config: config2,
+    locator
+  });
+  const actors = [
+    rewardRedemption
+  ].filter(exists$2);
+  for (const actor of actors) {
+    await orchestrator.registerActor(actor);
+  }
+  await orchestrator.start();
 }
 __name(runRewardRedemptionApi, "runRewardRedemptionApi");
 
@@ -352024,7 +351456,10 @@ async function localLocatorFromConfig(config2, context) {
       maxWindowSize: 1e4,
       syncInterval: 1e4
     }),
-    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {})
+    SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}),
+    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {
+      finalizedArchivist: readonlyChainArchivist
+    })
   ]);
   locator.freeze();
   return locator;
@@ -352064,7 +351499,9 @@ async function remoteLocatorFromConfig(config2, context) {
       maxWindowSize: 1e4,
       syncInterval: 1e4
     }),
-    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {})
+    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {
+      finalizedArchivist: readonlyChainArchivist
+    })
   ]);
   locator.freeze();
   return locator;
@@ -352081,6 +351518,27 @@ async function producerLocatorFromConfig(config2, context) {
   if (rewardAddress === account.address) {
     logger?.warn(`Using producer account address as reward address: ${account.address}`);
   }
+  const remoteUrl = config2.remote.rpc?.url;
+  if (isString$1(remoteUrl)) {
+    const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport(remoteUrl, schemas), "transportFactory");
+    locator.registerMany([
+      JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {
+        transport: await transportFactory(MempoolViewerRpcSchemas)
+      }),
+      JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {
+        transport: await transportFactory(MempoolRunnerRpcSchemas)
+      }),
+      JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {
+        transport: await transportFactory(AccountBalanceViewerRpcSchemas)
+      }),
+      JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {
+        transport: await transportFactory(FinalizationViewerRpcSchemas)
+      }),
+      JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {
+        transport: await transportFactory(BlockViewerRpcSchemas)
+      })
+    ]);
+  }
   locator.registerMany([
     SimpleBlockRewardViewer.factory(SimpleBlockRewardViewer.dependencies, {}),
     SimpleBlockRunner.factory(SimpleBlockRunner.dependencies, {
@@ -352092,6 +351550,68 @@ async function producerLocatorFromConfig(config2, context) {
   return locator;
 }
 __name(producerLocatorFromConfig, "producerLocatorFromConfig");
+function apiLocatorFromConfig(config2, context) {
+  const locator = new ProviderFactoryLocator(context);
+  locator.registerMany([]);
+  locator.freeze();
+  return locator;
+}
+__name(apiLocatorFromConfig, "apiLocatorFromConfig");
+function mempoolLocatorFromConfig(config2, context) {
+  const locator = new ProviderFactoryLocator(context);
+  locator.registerMany([]);
+  locator.freeze();
+  return locator;
+}
+__name(mempoolLocatorFromConfig, "mempoolLocatorFromConfig");
+async function bridgeLocatorFromConfig(config2, context) {
+  const locator = new ProviderFactoryLocator(context);
+  const { mnemonic } = config2.actors.bridge;
+  const walletPhrase = isDefined(mnemonic) ? mnemonic : HDWallet.generateMnemonic();
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
+  const signerAccount = await wallet.derivePath(ADDRESS_INDEX.XYO);
+  const remoteUrl = config2.actors.bridge.remote.rpc?.url;
+  if (isString$1(remoteUrl)) {
+    const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport(remoteUrl, schemas), "transportFactory");
+    locator.registerMany([
+      JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {
+        transport: await transportFactory(MempoolViewerRpcSchemas)
+      }),
+      JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {
+        transport: await transportFactory(MempoolRunnerRpcSchemas)
+      }),
+      JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {
+        transport: await transportFactory(AccountBalanceViewerRpcSchemas)
+      }),
+      JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {
+        transport: await transportFactory(FinalizationViewerRpcSchemas)
+      }),
+      JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {
+        transport: await transportFactory(BlockViewerRpcSchemas)
+      })
+    ]);
+  }
+  locator.registerMany([
+    SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
+      account: signerAccount
+    }),
+    SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}),
+    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
+    SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(bridgeLocatorFromConfig, "bridgeLocatorFromConfig");
+function rewardRedemptionLocatorFromConfig(config2, context) {
+  const locator = new ProviderFactoryLocator(context);
+  locator.registerMany([
+    SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(rewardRedemptionLocatorFromConfig, "rewardRedemptionLocatorFromConfig");
 async function locatorsFromConfig(actors, config2, context) {
   const result = {
     _root: await rootLocatorFromConfig(config2, context)
@@ -352100,6 +351620,22 @@ async function locatorsFromConfig(actors, config2, context) {
   if (producer) {
     result.producer = producer;
   }
+  const api = actors.includes("api") ? await apiLocatorFromConfig(config2, result._root.context) : void 0;
+  if (api) {
+    result.api = api;
+  }
+  const mempool = actors.includes("mempool") ? await mempoolLocatorFromConfig(config2, result._root.context) : void 0;
+  if (mempool) {
+    result.mempool = mempool;
+  }
+  const bridge = actors.includes("bridge") ? await bridgeLocatorFromConfig(config2, result._root.context) : void 0;
+  if (bridge) {
+    result.bridge = bridge;
+  }
+  const rewardRedemption = actors.includes("rewardRedemption") ? await rewardRedemptionLocatorFromConfig(config2, result._root.context) : void 0;
+  if (rewardRedemption) {
+    result.rewardRedemption = rewardRedemption;
+  }
   return result;
 }
 __name(locatorsFromConfig, "locatorsFromConfig");
@@ -352150,7 +351686,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined("1.19.7") ? "1.19.7" : "unknown";
+var version = isDefined("1.19.9") ? "1.19.9" : "unknown";
 function resolveConfig(config2) {
   const logger = console;
   const defaultChainId = toAddress("1");
@@ -352162,29 +351698,6 @@ function resolveConfig(config2) {
   return resolved;
 }
 __name(resolveConfig, "resolveConfig");
-var getContextFromConfig = /* @__PURE__ */ __name(async (configuration2) => {
-  const logger = initLogger(configuration2);
-  const orchestrator = await Orchestrator.create({
-    logger
-  });
-  process.on("SIGINT", () => {
-    void (async () => {
-      try {
-        logger.log("\nSIGINT received. Attempting graceful shutdown...");
-        await orchestrator?.stop();
-        logger.log("Orchestrator stopped, exiting now.");
-        process.exit(0);
-      } catch (err) {
-        logger.error("Error stopping orchestrator:", err);
-        process.exit(1);
-      }
-    })();
-  });
-  return {
-    logger,
-    orchestrator
-  };
-}, "getContextFromConfig");
 var getLocatorsFromConfig = /* @__PURE__ */ __name(async (actors, configuration2) => {
   const logger = initLogger(configuration2);
   const orchestrator = await Orchestrator.create({
@@ -352262,30 +351775,26 @@ $0 <command> [options]`).parserConfiguration({
   }).options(optionsFromGlobalZodRegistry()).wrap(y.terminalWidth()).command("api", "Run a XL1 API Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 API Node", () => {
     }, async () => {
-      const context = await getContextFromConfig(configuration);
-      await runApi({
-        ...context,
-        config: configuration,
-        singletons: {}
-      });
+      const { locators, orchestrator } = await getLocatorsFromConfig([
+        "api"
+      ], configuration);
+      await runApi(configuration, orchestrator, locators["api"]);
     });
   }).command("bridge", "Run a XL1 Bridge Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Bridge Node", () => {
     }, async () => {
-      const context = await getContextFromConfig(configuration);
-      runBridge({
-        ...context,
-        config: configuration
-      });
+      const { locators, orchestrator } = await getLocatorsFromConfig([
+        "bridge"
+      ], configuration);
+      await runBridge(configuration, orchestrator, locators["bridge"]);
     });
   }).command("mempool", "Run a XL1 Mempool Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Mempool Node", () => {
     }, async () => {
-      const context = await getContextFromConfig(configuration);
-      runMempool({
-        ...context,
-        config: configuration
-      });
+      const { locators, orchestrator } = await getLocatorsFromConfig([
+        "mempool"
+      ], configuration);
+      await runMempool(configuration, orchestrator, locators["mempool"]);
     });
   }).command("producer", "Run a XL1 Producer Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Producer Node", () => {
@@ -352298,31 +351807,23 @@ $0 <command> [options]`).parserConfiguration({
   }).command("reward-redemption-api", "Run a XL1 Rewards Redemption API Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Rewards Redemption API Node", () => {
     }, async () => {
-      const context = await getContextFromConfig(configuration);
-      runRewardRedemptionApi({
-        ...context,
-        config: configuration
-      });
+      const { locators, orchestrator } = await getLocatorsFromConfig([
+        "rewardRedemption"
+      ], configuration);
+      await runRewardRedemptionApi(configuration, orchestrator, locators["rewardRedemption"]);
     });
   }).command("$0", "Run a full XL1 Node", () => {
   }, async () => {
     if (configuration.actors.mempool.enabled) ;
-    const context = await getContextFromConfig(configuration);
     const { locators, orchestrator } = await getLocatorsFromConfig([
+      "api",
       "producer"
     ], configuration);
     if (configuration.actors.mempool.enabled) {
-      runMempool({
-        ...context,
-        config: configuration
-      });
+      await runMempool(configuration, orchestrator, locators["mempool"]);
       await waitForHostPort(configuration.actors.mempool.host, configuration.actors.mempool.port);
     }
-    await runApi({
-      ...context,
-      config: configuration,
-      singletons: {}
-    });
+    await runApi(configuration, orchestrator, locators["api"]);
     await waitForHostPort(configuration.actors.api.host, configuration.actors.api.port);
     await runProducer(configuration, orchestrator, locators["producer"]);
   }).options({
@@ -352349,3 +351850,4 @@ start().catch((err) => {
     // eslint-disable-next-line unicorn/no-process-exit
     process.exit(1);
 });
+//# sourceMappingURL=cli-min.mjs.map