@xyo-network/xl1-cli 1.16.23 → 1.16.25

package/dist/cli-min.mjs

@@ -33858,6 +33858,21 @@ var hexFrom = (value, config) => {
     }
   }
 };
+
+// src/hex/as.ts
+function asHex(value, assert) {
+  let stringValue = void 0;
+  switch (typeof value) {
+    case "string": {
+      stringValue = hexFromHexString(value);
+      break;
+    }
+    default: {
+      return assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+  return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`);
+}
 var UntypedHexZod = z.string().regex(HexRegEx, { message: "Invalid hex format" });
 var HexZod = UntypedHexZod.transform((val) => val);
 
@@ -39263,7 +39278,7 @@ function defineProperties(target, values, types) {
  *
  *  @_section: api/utils/errors:Errors  [about-errors]
  */
-function stringify$1(value, seen) {
+function stringify$2(value, seen) {
     if (value == null) {
         return "null";
     }
@@ -39277,7 +39292,7 @@ function stringify$1(value, seen) {
         seen.add(value);
     }
     if (Array.isArray(value)) {
-        return "[ " + (value.map((v) => stringify$1(v, seen))).join(", ") + " ]";
+        return "[ " + (value.map((v) => stringify$2(v, seen))).join(", ") + " ]";
     }
     if (value instanceof Uint8Array) {
         const HEX = "0123456789abcdef";
@@ -39289,7 +39304,7 @@ function stringify$1(value, seen) {
         return result;
     }
     if (typeof (value) === "object" && typeof (value.toJSON) === "function") {
-        return stringify$1(value.toJSON(), seen);
+        return stringify$2(value.toJSON(), seen);
     }
     switch (typeof (value)) {
         case "boolean":
@@ -39303,7 +39318,7 @@ function stringify$1(value, seen) {
         case "object": {
             const keys = Object.keys(value);
             keys.sort();
-            return "{ " + keys.map((k) => `${stringify$1(k, seen)}: ${stringify$1(value[k], seen)}`).join(", ") + " }";
+            return "{ " + keys.map((k) => `${stringify$2(k, seen)}: ${stringify$2(value[k], seen)}`).join(", ") + " }";
         }
     }
     return `[ COULD NOT SERIALIZE ]`;
@@ -39352,7 +39367,7 @@ function makeError(message, code, info) {
         const details = [];
         if (info) {
             if ("message" in info || "code" in info || "name" in info) {
-                throw new Error(`value will overwrite populated values: ${stringify$1(info)}`);
+                throw new Error(`value will overwrite populated values: ${stringify$2(info)}`);
             }
             for (const key in info) {
                 if (key === "shortMessage") {
@@ -39360,7 +39375,7 @@ function makeError(message, code, info) {
                 }
                 const value = (info[key]);
                 //                try {
-                details.push(key + "=" + stringify$1(value));
+                details.push(key + "=" + stringify$2(value));
                 //                } catch (error: any) {
                 //                console.log("MMM", error.message);
                 //                    details.push(key + "=[could not serialize object]");
@@ -71109,9 +71124,6 @@ var asAnyPayload = AsObjectFactory.create(isAnyPayload);
 function isPayloadOfSchemaType(schema) {
   return (x) => isAnyPayload(x) && x?.schema === schema;
 }
-var notPayloadOfSchemaType = (schema) => {
-  return (x) => !isAnyPayload(x) || x?.schema !== schema;
-};
 
 // src/Error.ts
 var ModuleErrorSchema = "network.xyo.error.module";
@@ -71123,25 +71135,12 @@ function isPayloadOfZodType(zodSchema, schema) {
     return zodSchema.safeParse(data).success;
   };
 }
-var PayloadBundleSchema = "network.xyo.payload.bundle";
 var SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/;
-var SchemaZodV1 = z.string().regex(SchemaRegEx);
-var SchemaZodV2 = z.string().regex(SchemaRegEx).transform((x) => x);
-var SchemaZod = z.union([SchemaZodV1, SchemaZodV2]);
+var SchemaZod = z.string().regex(SchemaRegEx);
 var PayloadSchema = "network.xyo.payload";
 z.literal(PayloadSchema);
-var isSchema = (value) => {
-  return SchemaZod.safeParse(value).error === void 0;
-};
-var isDataHashMeta = (value) => {
-  return isHash(value?._dataHash);
-};
-var isHashMeta = (value) => {
-  return isDataHashMeta(value) && isHash(value?._hash);
-};
-var isSequenceStorageMeta = (value) => {
-  return value?._sequence != void 0;
-};
+var isSchema = zodIsFactory(SchemaZod);
+var asSchema = zodAsFactory(SchemaZod, "asSchema");
 var isLocalSequence = (value) => {
   return isHex(value) && value.length === SequenceConstants.localSequenceBytes * 2;
 };
@@ -71294,24 +71293,23 @@ var QualifiedSequenceToStringZod$1 = z.string().regex(QualifiedSequenceRegex$1);
 var QualifiedSequenceFromStringZod$1 = z.string().regex(QualifiedSequenceRegex$1).transform((v) => toHex(v));
 z.union([LocalSequenceToStringZod$1, QualifiedSequenceToStringZod$1]);
 var SequenceFromStringZod = z.union([LocalSequenceFromStringZod$1, QualifiedSequenceFromStringZod$1]);
-var isStorageMeta = (value) => {
-  return isSequenceStorageMeta(value) && isHashMeta(value);
-};
 
 // src/PayloadZod.ts
 var HashMetaZod = z.object({
   _hash: HashZod,
   _dataHash: HashZod
 });
+var isHashMeta = zodIsFactory(HashMetaZod);
 z.object({ _sequence: SequenceFromStringZod });
 var StorageMetaZod = z.object({
   _hash: HashZod,
   _dataHash: HashZod,
   _sequence: SequenceFromStringZod
 });
+var isStorageMeta = zodIsFactory(StorageMetaZod);
 var PayloadZod = z.object({ schema: SchemaZod });
 PayloadZod.extend(StorageMetaZod.shape);
-var AnyPayloadZod = PayloadZod.catchall(z.json());
+var AnyPayloadZod = PayloadZod.loose();
 AnyPayloadZod.extend(StorageMetaZod.shape);
 function WithStorageMetaZod(valueZod) {
   return valueZod.extend(StorageMetaZod.shape);
@@ -71321,9 +71319,18 @@ function WithHashMetaZod(valueZod) {
 }
 var PayloadZodStrict = z.strictObject({ schema: SchemaZod });
 var PayloadZodLoose = z.looseObject({ schema: SchemaZod });
+var PayloadZodOfSchema$1 = (schema) => PayloadZod.extend({ schema: z.literal(schema) });
 var PayloadZodStrictOfSchema = (schema) => PayloadZodStrict.extend({ schema: z.literal(schema) });
 var PayloadZodLooseOfSchema = (schema) => PayloadZodLoose.extend({ schema: z.literal(schema) });
 
+// src/PayloadBundle.ts
+var PayloadBundleSchema = "network.xyo.payload.bundle";
+var PayloadBundleFieldsZod = z.object({
+  payloads: PayloadZodLoose.array(),
+  root: HashZod
+});
+PayloadZodOfSchema$1(PayloadBundleSchema).extend(PayloadBundleFieldsZod.shape);
+
 // src/Builder.ts
 var omitSchema = (payload) => {
   const result = structuredClone(payload);
@@ -71525,18 +71532,36 @@ var PayloadBuilder = class _PayloadBuilder {
 };
 
 // src/BoundWitness/BoundWitness.ts
-var asBlock = (bw) => bw;
 
 // src/BoundWitness/BoundWitnessSchema.ts
 var BoundWitnessSchema = "network.xyo.boundwitness";
-var isBoundWitness = (value) => isPayloadOfSchemaType(BoundWitnessSchema)(value);
-var notBoundWitness = notPayloadOfSchemaType(BoundWitnessSchema);
-var asBoundWitness = (payload) => isBoundWitness(payload) ? payload : void 0;
-var asOptionalBoundWitness = AsObjectFactory.createOptional(isBoundWitness);
-var isBoundWitnessWithStorageMeta = (value) => isPayloadOfSchemaType(BoundWitnessSchema)(value) && isStorageMeta(value);
-function isSigned(value) {
-  return isBoundWitness(value) && value.$signatures.length === value.addresses.length && value.addresses.length > 0;
-}
+var SignaturesMetaZod = z.object({ $signatures: z.array(z.union([HexZod, z.null()])) });
+var UnsignedSignaturesMetaZod = z.object({ $signatures: z.array(z.null()) });
+var SignedSignaturesMetaZod = z.object({ $signatures: z.array(HexZod) });
+
+// src/BoundWitness/BoundWitness.ts
+var BoundWitnessRequiredFieldsZod = z.object({
+  addresses: z.array(AddressZod),
+  payload_hashes: z.array(HashZod),
+  payload_schemas: z.array(SchemaZod),
+  previous_hashes: z.array(HashZod.nullable())
+});
+var BoundWitnessMetaZod = z.object({
+  $destination: AddressZod.optional(),
+  $sourceQuery: HashZod.optional()
+}).extend(SignaturesMetaZod.shape);
+var BoundWitnessZod = PayloadZod.safeExtend({ schema: z.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
@@ -73133,10 +73158,10 @@ var BoundWitnessBuilder = class _BoundWitnessBuilder extends PayloadBuilder {
     assertEx(!fields.payload_hashes.includes(null), () => "nulls found in hashes");
     assertEx(!fields.payload_schemas.includes(null), () => "nulls found in schemas");
   }
-  async build() {
+  async build(sign = true) {
     return await _BoundWitnessBuilder._buildMutex.runExclusive(async () => {
       const dataHashableFields = await this.dataHashableFields();
-      const $signatures = await this.sign();
+      const $signatures = sign ? await this.sign() : this.addresses.map(() => null);
       const ret = {
         ...this._meta,
         ...dataHashableFields,
@@ -73658,25 +73683,25 @@ var NumberishZod = z.union([z.number(), z.string(), z.bigint()]).transform((v) =
 
 // src/model/BlockNumber/BlockNumber.ts
 var BlockNumberZod = z.number().transform((v) => v);
-var NumberishBlockNumberZod = NumberishZod.transform((v) => v);
+var BlockNumberishZod = NumberishZod.transform((v) => v);
 var asBlockNumber = zodAsFactory(BlockNumberZod, "asBlockNumber");
 asBlockNumber(0);
 var EthBlockNumberZod = z.number().transform((v) => v);
-var NumberishEthBlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var EthBlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asEthBlockNumber = zodAsFactory(EthBlockNumberZod, "asEthBlockNumber");
 asEthBlockNumber(0);
 var XL1BlockNumberZod = z.number().transform((v) => v);
-var NumberishXL1BlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var XL1BlockNumberishZod = BlockNumberishZod.transform((v) => v);
 var asXL1BlockNumber = zodAsFactory(XL1BlockNumberZod, "asXL1BlockNumber");
 asXL1BlockNumber(0);
 var BlockRangeZod = z.tuple([BlockNumberZod, BlockNumberZod]);
-z.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod]);
+z.tuple([BlockNumberishZod, BlockNumberishZod]);
 z.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-z.tuple([NumberishEthBlockNumberZod, NumberishEthBlockNumberZod]);
+z.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var RangeZod = z.tuple([z.number(), z.number()]);
 var asRange = zodAsFactory(RangeZod, "Range");
 var XL1BlockRangeZod = z.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-z.tuple([NumberishXL1BlockNumberZod, NumberishXL1BlockNumberZod]);
+z.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory(XL1BlockRangeZod, "XL1BlockRange");
 var StepIdentityZod = object$3({
   block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
@@ -73686,36 +73711,257 @@ var StepIdentityZod = object$3({
 // src/payload/StepIdentityPayload.ts
 var StepIdentitySchema = "network.xyo.chain.step.identity";
 var isStepIdentityPayload = isPayloadOfZodType(StepIdentityZod, StepIdentitySchema);
-var isHydratedBoundWitness = (value) => {
-  return Array.isArray(value) && value.length === 2 && isBoundWitness(value[0]) && Array.isArray(value[1]) && !value[1].some((item) => !isAnyPayload(item));
-};
-var isTransactionBoundWitness = (value) => {
-  const typedObj = value;
-  return isBoundWitness(value) && isAddress(typedObj.chain) && typedObj.fees !== void 0 && typedObj.exp !== void 0 && typedObj.nbf !== void 0;
-};
+function base64Encode(u8) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return Buffer.from(u8).toString("base64");
+  }
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < u8.length; i += chunk) {
+    binary += String.fromCharCode(...u8.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const u8 = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
+  return u8;
+}
+var ArrayBufferToJsonZod = _instanceof(ArrayBuffer).transform((x) => {
+  const u8 = new Uint8Array(x);
+  return base64Encode(u8);
+});
+var JsonToArrayBufferZod = string$2().transform((x) => {
+  const u8 = base64Decode(x);
+  return u8.buffer;
+});
+var ChainZod = string$2().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
-// src/transaction/AnyHydratedTransaction.ts
-var isAnyHydratedTransaction = (value) => {
-  return isHydratedBoundWitness(value) && isTransactionBoundWitness(value[0]);
-};
-var isHydratedTransactionWithStorageMeta = (value) => {
-  return isAnyHydratedTransaction(value) && isStorageMeta(value[0]) && !value[1].some((v) => !isStorageMeta(v));
-};
-var asHydratedTransactionWithStorageMeta = AsObjectFactory.create(
-  isHydratedTransactionWithStorageMeta
+// src/zod/BlockBoundWitness.ts
+var BlockBoundWitnessFieldsZod = object$3({
+  block: XL1BlockNumberZod,
+  chain: ChainZod,
+  previous: HashZod.nullable(),
+  protocol: number$3().optional(),
+  step_hashes: array$1(HashZod).optional()
+});
+var BlockBoundWitnessMetaZod = object$3({ $epoch: number$3() });
+var BlockBoundWitnessZod = BoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
+var isBlockBoundWitness = zodIsFactory(BlockBoundWitnessZod);
+var asBlockBoundWitness = zodAsFactory(BlockBoundWitnessZod, "asBlockBoundWitness");
+var BlockBoundWitnessWithHashMetaZod = BlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var isBlockBoundWitnessWithHashMeta = zodIsFactory(BlockBoundWitnessWithHashMetaZod);
+var asBlockBoundWitnessWithHashMeta = zodAsFactory(BlockBoundWitnessWithHashMetaZod, "asBlockBoundWitnessWithHashMeta");
+var BlockBoundWitnessWithStorageMetaZod = BlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var asBlockBoundWitnessWithStorageMeta = zodAsFactory(BlockBoundWitnessWithStorageMetaZod, "asBlockBoundWitnessWithStorageMeta");
+var UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
+UnsignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
+UnsignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
+var asSignedBlockBoundWitness = zodAsFactory(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
+var SignedBlockBoundWitnessWithHashMetaZod = SignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory(SignedBlockBoundWitnessWithHashMetaZod);
+var SignedBlockBoundWitnessWithStorageMetaZod = SignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory(SignedBlockBoundWitnessWithStorageMetaZod);
+var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory(
+  SignedBlockBoundWitnessWithStorageMetaZod,
+  "asSignedBlockBoundWitnessWithStorageMeta"
 );
-var isSignedHydratedTransaction = (value) => {
-  return isAnyHydratedTransaction(value) && isSigned(value[0]);
-};
-var asSignedHydratedTransaction = AsObjectFactory.create(
-  isSignedHydratedTransaction
+tuple([
+  BlockBoundWitnessZod,
+  array$1(PayloadZodLoose)
+]);
+tuple([
+  WithHashMetaZod(BlockBoundWitnessZod),
+  array$1(WithHashMetaZod(PayloadZodLoose))
+]);
+tuple([
+  WithStorageMetaZod(BlockBoundWitnessZod),
+  array$1(WithStorageMetaZod(PayloadZodLoose))
+]);
+var SignedHydratedBlockZod = tuple([
+  SignedBlockBoundWitnessZod,
+  array$1(PayloadZodLoose)
+]);
+tuple([
+  SignedBlockBoundWitnessZod,
+  array$1(PayloadZodLoose)
+]);
+var SignedHydratedBlockWithHashMetaZod = tuple([
+  WithHashMetaZod(SignedBlockBoundWitnessZod),
+  array$1(WithHashMetaZod(PayloadZodLoose))
+]);
+var asSignedHydratedBlockWithHashMeta = zodAsFactory(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
+tuple([
+  WithStorageMetaZod(SignedBlockBoundWitnessZod),
+  array$1(WithStorageMetaZod(PayloadZodLoose))
+]);
+var AttoZod = bigint$1();
+var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
+var AttoToJsonZod = BigIntToJsonZod;
+var TransactionFeesHexZod = object$3({
+  base: HexZod,
+  gasLimit: HexZod,
+  gasPrice: HexZod,
+  priority: HexZod
+});
+var TransactionFeesBigIntZod = object$3({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod
+});
+TransactionFeesHexZod.transform((val) => ({
+  base: JsonToBigIntZod.parse(val.base),
+  gasLimit: JsonToBigIntZod.parse(val.gasLimit),
+  gasPrice: JsonToBigIntZod.parse(val.gasPrice),
+  priority: JsonToBigIntZod.parse(val.priority)
+}));
+TransactionFeesBigIntZod.transform((val) => ({
+  base: BigIntToJsonZod.parse(val.base),
+  gasLimit: BigIntToJsonZod.parse(val.gasLimit),
+  gasPrice: BigIntToJsonZod.parse(val.gasPrice),
+  priority: BigIntToJsonZod.parse(val.priority)
+}));
+
+// src/zod/TransactionBoundWitness.ts
+object$3({ nbf: XL1BlockNumberZod });
+object$3({ exp: XL1BlockNumberZod });
+var BlockDurationZod = object$3({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod });
+var BlockScriptsZod = object$3({ script: array$1(string$2()).optional() });
+var TransactionFeesZod = object$3({ fees: TransactionFeesHexZod });
+var TransactionBoundWitnessIdentityFields = object$3({ chain: ChainZod, from: AddressZod });
+var TransactionBoundWitnessFieldsZod = object$3().safeExtend(BlockDurationZod.shape).safeExtend(TransactionFeesZod.shape).safeExtend(TransactionBoundWitnessIdentityFields.shape).safeExtend(BlockScriptsZod.shape);
+var TransactionBoundWitnessZod = BoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+var isTransactionBoundWitness = zodIsFactory(TransactionBoundWitnessZod);
+TransactionBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var isTransactionBoundWitnessWithStorageMeta = zodIsFactory(TransactionBoundWitnessWithStorageMetaZod);
+var UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+UnsignedTransactionBoundWitnessZod.safeExtend(HashMetaZod.shape);
+UnsignedTransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.safeExtend(TransactionBoundWitnessFieldsZod.shape);
+var SignedTransactionBoundWitnessWithHashMetaZod = SignedTransactionBoundWitnessZod.safeExtend(HashMetaZod.shape);
+var asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory(
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  "asSignedTransactionBoundWitnessWithHashMeta"
 );
-var isSignedTransactionBoundWitness = (value) => {
-  return isTransactionBoundWitness(value) && isSigned(value);
-};
-var isTransactionBoundWitnessWithStorageMeta = (value) => isTransactionBoundWitness(value) && isStorageMeta(value);
-var isSignedTransactionBoundWitnessWithStorageMeta = (value) => isSignedTransactionBoundWitness(value) && isStorageMeta(value);
-var asTransactionBoundWitnessWithStorageMeta = AsObjectFactory.create(isTransactionBoundWitnessWithStorageMeta);
+var SignedTransactionBoundWitnessWithStorageMetaZod = SignedTransactionBoundWitnessZod.safeExtend(StorageMetaZod.shape);
+var isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory(SignedTransactionBoundWitnessWithStorageMetaZod);
+
+// src/zod/HydratedTransaction.ts
+tuple([
+  TransactionBoundWitnessZod,
+  array$1(PayloadZodLoose)
+]);
+tuple([
+  WithHashMetaZod(TransactionBoundWitnessZod),
+  array$1(WithHashMetaZod(PayloadZodLoose))
+]);
+tuple([
+  WithStorageMetaZod(TransactionBoundWitnessZod),
+  array$1(WithStorageMetaZod(PayloadZodLoose))
+]);
+var UnsignedHydratedTransactionZod = tuple([
+  UnsignedTransactionBoundWitnessZod,
+  array$1(PayloadZodLoose)
+]);
+tuple([
+  WithHashMetaZod(TransactionBoundWitnessZod),
+  array$1(WithHashMetaZod(PayloadZodLoose))
+]);
+tuple([
+  WithStorageMetaZod(TransactionBoundWitnessZod),
+  array$1(WithStorageMetaZod(PayloadZodLoose))
+]);
+var SignedHydratedTransactionZod = tuple([
+  SignedTransactionBoundWitnessZod,
+  array$1(PayloadZodLoose)
+]);
+var SignedHydratedTransactionWithHashMetaZod = tuple([
+  WithHashMetaZod(SignedTransactionBoundWitnessZod),
+  array$1(WithHashMetaZod(PayloadZodLoose))
+]);
+tuple([
+  WithStorageMetaZod(SignedTransactionBoundWitnessZod),
+  array$1(WithStorageMetaZod(PayloadZodLoose))
+]);
+var CaveatTypesZod = _enum$1(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = object$3({
+  type: CaveatTypesZod,
+  value: json$3()
+});
+var PermissionZod = object$3({
+  parentCapability: string$2(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: string$2()
+});
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: number$3().optional() });
+var PermissionRequestZod = record$1(string$2(), record$1(string$2(), any$1()));
+var RequestedPermissionZod = object$3({
+  parentCapability: string$2(),
+  date: number$3().optional()
+});
+var RewardsRangeOptionsZod = object$3({
+  positions: array$1(number$3()).optional(),
+  range: BlockRangeZod.optional(),
+  steps: array$1(StepIdentityZod).optional(),
+  stakers: array$1(AddressZod).optional()
+});
+var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
+var LocalSequenceToStringZod = string$2().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = string$2().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
+var QualifiedSequenceToStringZod = string$2().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = string$2().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+union$1([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+union$1([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+var StakeZod = object$3({
+  amount: AttoZod,
+  // the block number when the stake was added
+  addBlock: number$3(),
+  // the unique id for the stake item
+  id: number$3(),
+  // the block number when the stake was removed (set to 0 if not removed)
+  removeBlock: number$3(),
+  // the address that is being staked
+  staked: AddressZod,
+  // the address that owns the stake
+  staker: AddressZod,
+  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
+  withdrawBlock: number$3()
+});
+var StakeToJsonZod = StakeZod.transform((val) => ({
+  addBlock: val.addBlock,
+  amount: AttoToJsonZod.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: AddressZod.parse(val.staked),
+  staker: AddressZod.parse(val.staker),
+  withdrawBlock: val.withdrawBlock
+}));
+var JsonToStakeZod = StakeZod.extend({ amount: HexZod }).transform((val) => ({
+  addBlock: val.addBlock,
+  amount: JsonToAttoZod.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: val.staked,
+  staker: val.staker,
+  withdrawBlock: val.withdrawBlock
+}));
+var TimeDomainZod = union$1([
+  literal$2("xl1"),
+  literal$2("epoch"),
+  literal$2("ethereum")
+]);
+var TransferPairZod = z.tuple([
+  AddressZod,
+  AddressZod
+]);
 
 // src/block/AllowedBlockPayload.ts
 var AllowedBlockPayloadSchemas = [
@@ -73738,25 +73984,6 @@ var isAllowedBlockPayload = (value) => {
 var isAllowedBlockPayloadWithHashMeta = (value) => {
   return isAllowedBlockPayload(value) && isHashMeta(value);
 };
-var isBlockBoundWitness = (value) => {
-  const typedObj = value;
-  return isBoundWitness(value) && Number.isInteger(typedObj.block) && isHex(typedObj.chain);
-};
-var isBlockBoundWitnessWithStorageMeta = (value) => {
-  return isBlockBoundWitness(value) && isStorageMeta(value);
-};
-var isBlockBoundWitnessWithHashMeta = (value) => {
-  return isBlockBoundWitness(value) && isHashMeta(value);
-};
-var asBlockBoundWitness = AsObjectFactory.create(isBlockBoundWitness);
-var asBlockBoundWitnessWithStorageMeta = AsObjectFactory.create(isBlockBoundWitnessWithStorageMeta);
-var asBlockBoundWitnessWithHashMeta = AsObjectFactory.create(isBlockBoundWitnessWithHashMeta);
-var isHydratedBlock = (value) => {
-  return isHydratedBoundWitness(value) && isBlockBoundWitnessWithStorageMeta(value[0]);
-};
-var asHydratedBlock = AsObjectFactory.create(
-  isHydratedBlock
-);
 
 // src/constants/addresses.ts
 var XYO_ZERO_ADDRESS = "0000000000000000000000000000000000000000";
@@ -76034,12 +76261,12 @@ var asAttachableArchivistInstance = AsObjectFactory.create(isAttachableArchivist
 
 // src/Config.ts
 var ArchivistConfigSchema = "network.xyo.archivist.config";
-var tryGetTypedBoundWitness = async (archivist, hash, identity) => {
+var tryGetTypedBoundWitnessWithStorageMeta = async (archivist, hash, identity) => {
   const payload = (await archivist.get([hash])).at(0);
   return identity(payload) ? payload : void 0;
 };
 var tryHydrateTypedBoundWitness = async (archivist, hashOrBw, identity) => {
-  const bw = isHash(hashOrBw) ? await tryGetTypedBoundWitness(archivist, hashOrBw, identity) : hashOrBw;
+  const bw = isHash(hashOrBw) ? await tryGetTypedBoundWitnessWithStorageMeta(archivist, hashOrBw, identity) : hashOrBw;
   return bw ? [bw, (await archivist.get(bw?.payload_hashes)).filter(exists$1)] : void 0;
 };
 
@@ -76123,7 +76350,7 @@ var BoundWitnessValidator = class _BoundWitnessValidator extends PayloadValidato
         this.obj.addresses?.map(async (address, index) => _BoundWitnessValidator.validateSignature(
           toArrayBuffer(await PayloadBuilder.dataHash(this.payload)),
           toArrayBuffer(asAddress(address, true)),
-          toArrayBuffer(this.obj.$signatures?.[index])
+          toArrayBuffer(this.obj.$signatures?.[index] ?? void 0)
         )) ?? []
       )).flat()
     ];
@@ -81322,7 +81549,7 @@ var hydrateBlock = /* @__PURE__ */ __name$k(async ({ chainMap }, hash, maxDepth
   ];
 }, "hydrateBlock");
 var transactionsFromHydratedBlock = /* @__PURE__ */ __name$k((block) => {
-  return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta);
+  return block[1].filter(isTransactionBoundWitnessWithStorageMeta);
 }, "transactionsFromHydratedBlock");
 var LruCacheMap = class {
   static {
@@ -81593,9 +81820,7 @@ async function balancesSummary(context) {
   return await spanRootAsync("balancesSummary", async () => {
     const [headHash] = await context.head();
     const headResult = await context.store.chainMap.get(headHash);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${headHash}`, {
-      required: true
-    });
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${headHash}`);
     const rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange([
       rangeStart,
@@ -81625,7 +81850,7 @@ async function schemasStepSummaryFromRange(context, range) {
     const [block, payloads] = await hydrateBlock(context.store, hash);
     const boundWitnesses = [
       block,
-      ...payloads.filter(isBoundWitnessWithStorageMeta)
+      ...payloads.filter((x) => isBoundWitness(x) && isHashMeta(x))
     ];
     const schemas = {};
     for (const bw of boundWitnesses) {
@@ -81670,17 +81895,14 @@ async function schemasStepSummaryFromRange(context, range) {
       }
     }
   }
-  const finalResult = await PayloadBuilder.addStorageMeta(result);
-  return finalResult;
+  return await PayloadBuilder.addHashMeta(result);
 }
 __name$k(schemasStepSummaryFromRange, "schemasStepSummaryFromRange");
 async function schemasSummary(context) {
   return await spanRootAsync("schemasSummary", async () => {
     const [headHash] = await context.head();
     const headResult = await context.store.chainMap.get(headHash);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${headHash}`, {
-      required: true
-    });
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${headHash}`);
     const rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange([
       rangeStart,
@@ -81703,9 +81925,7 @@ async function transfersSummary(transferContext) {
   return await spanRootAsync("transferSummary", async () => {
     const [headHash] = await transferContext.head();
     const headResult = await transferContext.store.chainMap.get(headHash);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${transferContext.head}`, {
-      required: true
-    });
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${transferContext.head}`);
     const rangeStart = asXL1BlockNumber(isDefined(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange([
       rangeStart,
@@ -81866,6 +82086,215 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4, t
   return result;
 }
 __name$k(withContextCacheResponse, "withContextCacheResponse");
+async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
+  if (from === void 0 && Array.isArray(signer)) {
+    throw new Error("from is required when signer is an array");
+  }
+  const txBoundWitnessFields = {
+    chain,
+    fees: {
+      base: toHex(fees.base),
+      gasLimit: toHex(fees.gasLimit),
+      gasPrice: toHex(fees.gasPrice),
+      priority: toHex(fees.priority)
+    },
+    nbf,
+    exp
+  };
+  const elevatedHashes = await PayloadBuilder.hashes(onChainPayloads);
+  const script = [];
+  for (const elevatedHash of elevatedHashes) {
+    script.push(`elevate|${elevatedHash}`);
+  }
+  const fields = {
+    ...txBoundWitnessFields,
+    from: from ?? (Array.isArray(signer) ? assertEx(signer.at(0)?.address) : signer.address)
+  };
+  if (script.length > 0) {
+    fields.script = script;
+  }
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).signers(Array.isArray(signer) ? signer : [
+    signer
+  ]).build();
+  return [
+    await PayloadBuilder.addHashMeta(tx),
+    await PayloadBuilder.addHashMeta(txPayloads)
+  ];
+}
+__name$k(buildTransaction, "buildTransaction");
+async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads, nbf, exp, from, fees = defaultTransactionFees) {
+  const txBoundWitnessFields = {
+    chain,
+    fees: {
+      base: toHex(fees.base),
+      gasLimit: toHex(fees.gasLimit),
+      gasPrice: toHex(fees.gasPrice),
+      priority: toHex(fees.priority)
+    },
+    nbf,
+    exp
+  };
+  const elevatedHashes = await PayloadBuilder.hashes(onChainPayloads);
+  const script = [];
+  for (const elevatedHash of elevatedHashes) {
+    script.push(`elevate|${elevatedHash}`);
+  }
+  const fields = {
+    ...txBoundWitnessFields,
+    from
+  };
+  if (script.length > 0) {
+    fields.script = script;
+  }
+  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
+    $signatures: []
+  }).payloads([
+    ...onChainPayloads,
+    ...offChainPayloads
+  ]).build(false);
+  return [
+    tx,
+    txPayloads
+  ];
+}
+__name$k(buildUnsignedTransaction, "buildUnsignedTransaction");
+var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
+var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
+var confirmSubmittedTransaction = /* @__PURE__ */ __name$k(async (viewer, txHash, options) => {
+  const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options ?? {};
+  options?.logger?.log("\u{1F680} confirming transaction:", txHash, "\n");
+  let attempts = 0;
+  while (true) {
+    const tx = await viewer.transactionByHash(txHash) ?? void 0;
+    if (isDefined(tx)) {
+      options?.logger?.log("\u2705 Transaction confirmed:", txHash, "\n");
+      return tx;
+    } else {
+      attempts++;
+      if (attempts > maxAttempts) {
+        options?.logger?.error(`\u26A0\uFE0F Transaction not confirmed after ${maxAttempts} attempts`);
+        throw new Error(`Transaction ${txHash} not confirmed after ${maxAttempts} attempts`);
+      } else {
+        options?.logger?.log(`\u{1F504} Transaction not confirmed yet, attempt ${attempts}. Retrying...`, "\n");
+        await delay$1(attemptDelay);
+      }
+    }
+  }
+}, "confirmSubmittedTransaction");
+var tryHydrateTransaction = /* @__PURE__ */ __name$k(async ({ chainMap }, hash) => {
+  return await tryHydrateTypedBoundWitness({
+    get(hashes) {
+      return chainMap.getMany(hashes);
+    },
+    next() {
+      throw new Error("Not implemented");
+    }
+  }, hash, isSignedTransactionBoundWitnessWithStorageMeta);
+}, "tryHydrateTransaction");
+var flattenHydratedTransaction = /* @__PURE__ */ __name$k((hydratedTransaction) => {
+  const [tx, txPayloads] = hydratedTransaction;
+  return [
+    ...txPayloads,
+    tx
+  ];
+}, "flattenHydratedTransaction");
+var flattenHydratedTransactions = /* @__PURE__ */ __name$k((hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx)), "flattenHydratedTransactions");
+function transactionBlockByteCount([transaction, payloads]) {
+  const cleanTransaction = PayloadBuilder.omitStorageMeta(transaction);
+  const transactionBytes = JSON.stringify(cleanTransaction).length;
+  const cleanPayloads = PayloadBuilder.omitStorageMeta(payloads);
+  return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
+}
+__name$k(transactionBlockByteCount, "transactionBlockByteCount");
+
+// src/transaction/primitives/transactionOperations.ts
+function crackOperation(operation) {
+  const parts = operation.split("|");
+  if (parts.length < 2) {
+    throw new Error(`Invalid operation format: ${operation}`);
+  }
+  return [
+    parts[0],
+    parts.slice(1)
+  ];
+}
+__name$k(crackOperation, "crackOperation");
+function crackOperations(operations) {
+  return operations.map((op) => crackOperation(op));
+}
+__name$k(crackOperations, "crackOperations");
+
+// src/transaction/primitives/transactionElevatedPayloads.ts
+function transactionElevatedPayloadHashes(transaction) {
+  const elevateOperations = crackOperations(transaction.script ?? []).filter((op) => op[0] === "elevate");
+  return elevateOperations.map((op) => asHash(op[1][0], true));
+}
+__name$k(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
+function transactionElevatedPayloads([transaction, payloads]) {
+  const hashes = transactionElevatedPayloadHashes(transaction);
+  const elevatedPayloads2 = payloads.filter((payload) => hashes.includes(payload._hash));
+  return elevatedPayloads2;
+}
+__name$k(transactionElevatedPayloads, "transactionElevatedPayloads");
+function transactionBytesRequiredGas([transaction, payloads]) {
+  const transactionBlockBytes = transactionBlockByteCount([
+    transaction,
+    payloads
+  ]);
+  return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
+}
+__name$k(transactionBytesRequiredGas, "transactionBytesRequiredGas");
+function transactionRequiredGas(hydratedTransaction) {
+  const elevatedPayloads2 = transactionElevatedPayloads(hydratedTransaction);
+  const hashes = elevatedPayloads2.length + 1;
+  const signatures = hydratedTransaction[0].addresses.length;
+  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads2.length));
+}
+__name$k(transactionRequiredGas, "transactionRequiredGas");
+var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name$k((strings) => {
+  const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
+  return filterAs(hashes, (h) => asHash(h));
+}, "tryExtractElevatedHashesFromScript");
+var tryExtractElevatedHashes = /* @__PURE__ */ __name$k((tx) => {
+  const [bw, payloads] = tx;
+  const { script } = bw;
+  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
+  return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
+}, "tryExtractElevatedHashes");
+var extractElevatedHashes = /* @__PURE__ */ __name$k((tx) => {
+  const [bw, payloads] = tx;
+  const { script } = bw;
+  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
+  const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
+  assertEx(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  return filtered;
+}, "extractElevatedHashes");
+async function signTransaction(tx, account) {
+  assertEx(tx.from === account.address, () => "Signer address does not match transaction from address");
+  const unsignedTx = structuredClone(tx);
+  unsignedTx.addresses = [
+    account.address
+  ];
+  unsignedTx.previous_hashes = [
+    account.previousHash ?? null
+  ];
+  const hash = await PayloadBuilder.dataHash(unsignedTx);
+  const hashBytes = toArrayBuffer(hash);
+  const [signature] = await account.sign(hashBytes);
+  const result = {
+    ...unsignedTx,
+    $signatures: [
+      hexFromArrayBuffer(signature)
+    ]
+  };
+  return result;
+}
+__name$k(signTransaction, "signTransaction");
 
 // src/block/primitives/blockFromBlockNumber.ts
 async function blockFromBlockNumber(context, blockNumber) {
@@ -81873,9 +82302,10 @@ async function blockFromBlockNumber(context, blockNumber) {
   return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
     const [headHash] = await context.head();
     const result = await context.store.chainMap.get(headHash);
-    let currentBlock = asBlockBoundWitnessWithStorageMeta(result, () => `Head block not found for hash: ${headHash}`, {
-      required: true
-    });
+    if (!isDefined(result)) {
+      throw new Error(`Head block not found for hash: ${headHash}`);
+    }
+    let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(result, () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`);
     if (currentBlock.block < blockNumber) {
       throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
     }
@@ -81886,12 +82316,16 @@ async function blockFromBlockNumber(context, blockNumber) {
         const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 1;
         if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
           jumpBlockNumber = possibleJumpBlockNumber;
-          jumpHash = asHash(currentBlock.step_hashes.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
+          jumpHash = asHash(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
         }
       }
       const newBlock = await context.store.chainMap.get(asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString$1(currentBlock, 10)}`));
-      currentBlock = asBlockBoundWitnessWithStorageMeta(newBlock, () => `Block not found for hash: ${jumpHash}`, {
-        required: true
+      if (!isDefined(newBlock)) {
+        throw new Error(`Block not found for jump hash: ${jumpHash}`);
+      }
+      currentBlock = asSignedBlockBoundWitnessWithStorageMeta(newBlock, () => {
+        const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
+        return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
       });
       if (currentBlock.block === blockNumber) {
         break;
@@ -82061,14 +82495,6 @@ var ApiConfigZod = object$3({
     type: "number"
   })
 });
-var AppConfigZod = object$3({
-  port: number$2().default(3e3).register(globalRegistry, {
-    default: 3e3,
-    description: "Port for the application",
-    title: "app.port",
-    type: "number"
-  })
-});
 var BridgeConfigZod = object$3({
   host: string$2().default("localhost").register(globalRegistry, {
     default: "localhost",
@@ -82200,11 +82626,6 @@ var ProducerConfigZod = object$3({
     title: "allowlist",
     type: "array"
   })),
-  apiEndpoint: string$2().optional().register(globalRegistry, {
-    description: "Endpoint of the API to use for chain data",
-    title: "producer.apiEndpoint",
-    type: "string"
-  }),
   disableIntentRedeclaration: boolean$1().optional().register(globalRegistry, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
@@ -82271,6 +82692,18 @@ var RewardRedemptionApiConfigZod = object$3({
     type: "number"
   })
 });
+var ServicesConfigZod = object$3({
+  accountBalanceViewerEndpoint: string$2().optional().register(globalRegistry, {
+    description: "Endpoint of the API to use for instantiating an external AccountBalanceViewer",
+    title: "services.accountBalanceViewerEndpoint",
+    type: "string"
+  }),
+  apiEndpoint: string$2().optional().register(globalRegistry, {
+    description: "Endpoint of the API to use for instantiating an external Viewers",
+    title: "services.apiEndpoint",
+    type: "string"
+  })
+});
 var hasMongoConfig = /* @__PURE__ */ __name$k((config) => {
   if (isUndefined$1(config)) return false;
   return isDefined(config.connectionString) && isDefined(config.database) && isDefined(config.domain) && isDefined(config.password) && isDefined(config.username);
@@ -82311,6 +82744,23 @@ var StorageConfigZod = object$3({
     type: "string"
   })
 }).describe("Storage configuration options");
+var MetricsScrapeConfigZod = object$3({
+  path: string$2().default("/metrics").register(globalRegistry, {
+    default: "/metrics",
+    description: "Path for the metrics scrape endpoint",
+    title: "telemetry.metrics.scrape.path",
+    type: "string"
+  }),
+  port: number$2().default(9464).register(globalRegistry, {
+    default: 9464,
+    description: "Port for the metrics scrape endpoint",
+    title: "telemetry.metrics.scrape.port",
+    type: "number"
+  })
+}).describe("Metrics scrape configuration");
+var MetricsConfigZod = object$3({
+  scrape: MetricsScrapeConfigZod
+}).describe("Metrics configuration options");
 var OpenTelemetryConfigZod = object$3({
   // OpenTelemetry options
   otlpEndpoint: url().optional().register(globalRegistry, {
@@ -82320,6 +82770,8 @@ var OpenTelemetryConfigZod = object$3({
   })
 });
 var TelemetryConfigZod = object$3({
+  // Metrics configuration
+  metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
@@ -82353,13 +82805,13 @@ var Xl1CommonConfigSchema = object$3({
 var ConfigZod = object$3({
   ...Xl1CommonConfigSchema.shape,
   api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
-  app: AppConfigZod.default(AppConfigZod.parse({})).describe("Configuration for the application"),
   bridge: BridgeConfigZod.default(BridgeConfigZod.parse({})).describe("Configuration for the Bridge node"),
   chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
   evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
   mempool: MempoolConfigZod.default(MempoolConfigZod.parse({})).describe("Configuration for the mempool"),
   producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe("Configuration for the producer"),
   rewardRedemptionApi: RewardRedemptionApiConfigZod.default(RewardRedemptionApiConfigZod.parse({})).describe("Configuration for the rewards redemption API"),
+  services: ServicesConfigZod.default(ServicesConfigZod.parse({})).describe("Configuration for the global services"),
   storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
   telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
   validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")
@@ -82457,17 +82909,26 @@ var isChainIndexingServiceState = /* @__PURE__ */ __name$k((payload) => {
 }, "isChainIndexingServiceState");
 var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name$k((value) => isChainIndexingServiceState(value) && isStorageMeta(value), "isChainIndexingServiceStateWithStorageMeta");
 var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory$1.create(isChainIndexingServiceStateWithStorageMeta);
-var SimpleAccountBalanceViewer = class {
+var SimpleAccountBalanceViewer = class extends AbstractCreatable {
   static {
     __name$k(this, "SimpleAccountBalanceViewer");
   }
-  blockViewer;
-  context;
-  transferContext;
-  constructor(context, transferContext, blockViewer) {
-    this.context = context;
-    this.transferContext = transferContext;
-    this.blockViewer = blockViewer;
+  get blockViewer() {
+    return this.params.blockViewer;
+  }
+  get context() {
+    return this.params.context;
+  }
+  get transferContext() {
+    return this.params.transferContext;
+  }
+  static async paramsHandler(params) {
+    assertEx(params.blockViewer, () => "blockViewer is required");
+    assertEx(params.context, () => "context is required");
+    assertEx(params.transferContext, () => "transferContext is required");
+    return {
+      ...await super.paramsHandler(params)
+    };
   }
   async accountBalance(address, headOrRange) {
     const balances = await this.accountsBalances([
@@ -82889,214 +83350,6 @@ var SimpleDataLakeViewer = class {
     return this._signer;
   }
 });
-async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
-  if (from === void 0 && Array.isArray(signer)) {
-    throw new Error("from is required when signer is an array");
-  }
-  const txBoundWitnessFields = {
-    chain,
-    fees: {
-      base: toHex(fees.base),
-      gasLimit: toHex(fees.gasLimit),
-      gasPrice: toHex(fees.gasPrice),
-      priority: toHex(fees.priority)
-    },
-    nbf,
-    exp
-  };
-  const elevatedHashes = await PayloadBuilder.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
-  }
-  const fields = {
-    ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx(signer.at(0)?.address) : signer.address)
-  };
-  if (script.length > 0) {
-    fields.script = script;
-  }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
-    $signatures: []
-  }).payloads([
-    ...onChainPayloads,
-    ...offChainPayloads
-  ]).signers(Array.isArray(signer) ? signer : [
-    signer
-  ]).build();
-  return [
-    await PayloadBuilder.addStorageMeta(tx),
-    await PayloadBuilder.addStorageMeta(txPayloads)
-  ];
-}
-__name$k(buildTransaction, "buildTransaction");
-async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads, nbf, exp, from, fees = defaultTransactionFees) {
-  const txBoundWitnessFields = {
-    chain,
-    fees: {
-      base: toHex(fees.base),
-      gasLimit: toHex(fees.gasLimit),
-      gasPrice: toHex(fees.gasPrice),
-      priority: toHex(fees.priority)
-    },
-    nbf,
-    exp
-  };
-  const elevatedHashes = await PayloadBuilder.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
-  }
-  const fields = {
-    ...txBoundWitnessFields,
-    from
-  };
-  if (script.length > 0) {
-    fields.script = script;
-  }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({
-    $signatures: []
-  }).payloads([
-    ...onChainPayloads,
-    ...offChainPayloads
-  ]).build();
-  return [
-    tx,
-    txPayloads
-  ];
-}
-__name$k(buildUnsignedTransaction, "buildUnsignedTransaction");
-var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
-var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
-var confirmSubmittedTransaction = /* @__PURE__ */ __name$k(async (viewer, txHash, options) => {
-  const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options ?? {};
-  options?.logger?.log("\u{1F680} confirming transaction:", txHash, "\n");
-  let attempts = 0;
-  while (true) {
-    const tx = await viewer.transactionByHash(txHash) ?? void 0;
-    if (isDefined(tx)) {
-      options?.logger?.log("\u2705 Transaction confirmed:", txHash, "\n");
-      return tx;
-    } else {
-      attempts++;
-      if (attempts > maxAttempts) {
-        options?.logger?.error(`\u26A0\uFE0F Transaction not confirmed after ${maxAttempts} attempts`);
-        throw new Error(`Transaction ${txHash} not confirmed after ${maxAttempts} attempts`);
-      } else {
-        options?.logger?.log(`\u{1F504} Transaction not confirmed yet, attempt ${attempts}. Retrying...`, "\n");
-        await delay$1(attemptDelay);
-      }
-    }
-  }
-}, "confirmSubmittedTransaction");
-var tryHydrateTransaction = /* @__PURE__ */ __name$k(async ({ chainMap }, hash) => {
-  return await tryHydrateTypedBoundWitness({
-    get(hashes) {
-      return chainMap.getMany(hashes);
-    },
-    next() {
-      throw new Error("Not implemented");
-    }
-  }, hash, isSignedTransactionBoundWitnessWithStorageMeta);
-}, "tryHydrateTransaction");
-var flattenHydratedTransaction = /* @__PURE__ */ __name$k((hydratedTransaction) => {
-  const [tx, txPayloads] = hydratedTransaction;
-  return [
-    ...txPayloads,
-    tx
-  ];
-}, "flattenHydratedTransaction");
-var flattenHydratedTransactions = /* @__PURE__ */ __name$k((hydratedTransactions) => hydratedTransactions.flatMap((tx) => flattenHydratedTransaction(tx)), "flattenHydratedTransactions");
-function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder.omitStorageMeta(transaction);
-  const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder.omitStorageMeta(payloads);
-  return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
-}
-__name$k(transactionBlockByteCount, "transactionBlockByteCount");
-
-// src/transaction/primitives/transactionOperations.ts
-function crackOperation(operation) {
-  const parts = operation.split("|");
-  if (parts.length < 2) {
-    throw new Error(`Invalid operation format: ${operation}`);
-  }
-  return [
-    parts[0],
-    parts.slice(1)
-  ];
-}
-__name$k(crackOperation, "crackOperation");
-function crackOperations(operations) {
-  return operations.map((op) => crackOperation(op));
-}
-__name$k(crackOperations, "crackOperations");
-
-// src/transaction/primitives/transactionElevatedPayloads.ts
-function transactionElevatedPayloadHashes(transaction) {
-  const elevateOperations = crackOperations(transaction.script ?? []).filter((op) => op[0] === "elevate");
-  return elevateOperations.map((op) => asHash(op[1][0], true));
-}
-__name$k(transactionElevatedPayloadHashes, "transactionElevatedPayloadHashes");
-function transactionElevatedPayloads([transaction, payloads]) {
-  const hashes = transactionElevatedPayloadHashes(transaction);
-  const elevatedPayloads2 = payloads.filter((payload) => hashes.includes(payload._hash));
-  return elevatedPayloads2;
-}
-__name$k(transactionElevatedPayloads, "transactionElevatedPayloads");
-function transactionBytesRequiredGas([transaction, payloads]) {
-  const transactionBlockBytes = transactionBlockByteCount([
-    transaction,
-    payloads
-  ]);
-  return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes));
-}
-__name$k(transactionBytesRequiredGas, "transactionBytesRequiredGas");
-function transactionRequiredGas(hydratedTransaction) {
-  const elevatedPayloads2 = transactionElevatedPayloads(hydratedTransaction);
-  const hashes = elevatedPayloads2.length + 1;
-  const signatures = hydratedTransaction[0].addresses.length;
-  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction) + TransactionGasCosts.hashValidation * BigInt(hashes) + TransactionGasCosts.signatureValidation * BigInt(signatures) + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads2.length));
-}
-__name$k(transactionRequiredGas, "transactionRequiredGas");
-var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name$k((strings) => {
-  const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
-  return filterAs(hashes, (h) => asHash(h));
-}, "tryExtractElevatedHashesFromScript");
-var tryExtractElevatedHashes = /* @__PURE__ */ __name$k((tx) => {
-  const [bw, payloads] = tx;
-  const { script } = bw;
-  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
-  return payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-}, "tryExtractElevatedHashes");
-var extractElevatedHashes = /* @__PURE__ */ __name$k((tx) => {
-  const [bw, payloads] = tx;
-  const { script } = bw;
-  const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
-  const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-  assertEx(filtered.length === hashes.length, () => "Invalid elevated hashes");
-  return filtered;
-}, "extractElevatedHashes");
-async function signTransaction(tx, account) {
-  assertEx(tx.from === account.address, () => "Signer address does not match transaction from address");
-  const signedTx = structuredClone(tx);
-  signedTx.addresses = [
-    account.address
-  ];
-  signedTx.previous_hashes = [
-    account.previousHash ?? null
-  ];
-  const hash = await PayloadBuilder.dataHash(signedTx);
-  const hashBytes = toArrayBuffer(hash);
-  const [signature] = await account.sign(hashBytes);
-  signedTx.$signatures = [
-    hexFromArrayBuffer(signature)
-  ];
-  return signedTx;
-}
-__name$k(signTransaction, "signTransaction");
-
-// src/simple/gateway/SimpleXyoGatewayRunner.ts
 var SimpleXyoGatewayRunner = class {
   static {
     __name$k(this, "SimpleXyoGatewayRunner");
@@ -83128,8 +83381,8 @@ var SimpleXyoGatewayRunner = class {
     const viewer = assertEx(this.connectionInstance.viewer, () => "No viewer available on connection");
     const { nbf, exp, chain, fees } = options ?? {};
     const resolvedChainId = isDefined(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = isDefined(nbf) ? nbf : await viewer?.currentBlockNumber();
-    const resolvedExp = isDefined(exp) ? exp : resolvedNbf + 10;
+    const resolvedNbf = asXL1BlockNumber(isDefined(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber(isDefined(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await (await this.signer()).address(), fees);
     return await this.addTransactionToChain(tx);
   }
@@ -83384,10 +83637,10 @@ var SimpleXyoSigner = class {
   }
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this._account);
-    return [
+    return SignedHydratedTransactionWithHashMetaZod.parse([
       await PayloadBuilder.addStorageMeta(txBW),
       await PayloadBuilder.addStorageMeta(tx[1])
-    ];
+    ]);
   }
 };
 var SimpleTimeSyncViewer = class {
@@ -83496,269 +83749,16 @@ async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   return assertEx(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name$k(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
-function base64Encode(u8) {
-  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
-    return Buffer.from(u8).toString("base64");
-  }
-  let binary = "";
-  const chunk = 32768;
-  for (let i = 0; i < u8.length; i += chunk) {
-    binary += String.fromCharCode(...u8.subarray(i, i + chunk));
-  }
-  return btoa(binary);
-}
-__name$k(base64Encode, "base64Encode");
-function base64Decode(b64) {
-  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
-    return new Uint8Array(Buffer.from(b64, "base64"));
-  }
-  const binary = atob(b64);
-  const u8 = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
-  return u8;
-}
-__name$k(base64Decode, "base64Decode");
-var ArrayBufferToJsonZod = _instanceof(ArrayBuffer).transform((x) => {
-  const u8 = new Uint8Array(x);
-  return base64Encode(u8);
-});
-var JsonToArrayBufferZod = string$2().transform((x) => {
-  const u8 = base64Decode(x);
-  return u8.buffer;
-});
-var BoundWitnessRequiredFieldsZod = object$3({
-  addresses: array$1(AddressZod),
-  payload_hashes: array$1(HashZod),
-  payload_schemas: array$1(SchemaZod),
-  previous_hashes: array$1(HashZod.nullable())
-});
-var BoundWitnessMetaZod = object$3({
-  $destination: AddressZod.optional(),
-  $sourceQuery: HashZod.optional(),
-  $signatures: array$1(union$1([
-    HexZod,
-    _null$1()
-  ]))
-});
-var BoundWitnessZod = PayloadZod.extend({
-  schema: literal$2(BoundWitnessSchema)
-}).extend(BoundWitnessRequiredFieldsZod.shape).extend(BoundWitnessMetaZod.shape).refine((data) => data.$signatures.length === data.addresses.length, {
-  message: "$signatures length must equal addresses length"
-});
-BoundWitnessZod.catchall(any$1());
-var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), {
-  message: "all $signatures must be null"
-});
-UnsignedBoundWitnessZod.catchall(any$1());
-var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape).safeExtend(StorageMetaZod.shape);
-var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), {
-  message: "all $signatures must not be null"
-});
-UnsignedBoundWitnessZod.catchall(any$1());
-UnsignedBoundWitnessWithStorageMetaZod.catchall(any$1());
-var ChainZod = string$2().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
-
-// src/zod/BlockBoundWitness.ts
-var BlockBoundWitnessFieldsZod = object$3({
-  block: XL1BlockNumberZod,
-  chain: ChainZod,
-  previous: HashZod.nullable(),
-  protocol: number$3(),
-  step_hashes: array$1(HashZod).optional()
-});
-var BlockBoundWitnessMetaZod = object$3({
-  $epoch: number$3()
-});
-var BlockBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
-var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
-tuple([
-  BlockBoundWitnessZod,
-  array$1(PayloadZodLoose)
-]);
-tuple([
-  WithStorageMetaZod(BlockBoundWitnessZod),
-  array$1(WithStorageMetaZod(PayloadZodLoose))
-]);
-var SignedHydratedBlockZod = tuple([
-  SignedBlockBoundWitnessZod,
-  array$1(PayloadZodLoose)
-]);
-tuple([
-  SignedBlockBoundWitnessZod,
-  array$1(PayloadZodLoose)
-]);
-tuple([
-  WithStorageMetaZod(SignedBlockBoundWitnessZod),
-  array$1(WithStorageMetaZod(PayloadZodLoose))
-]);
-var AttoZod = bigint$1();
-var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
-var AttoToJsonZod = BigIntToJsonZod;
-var TransactionFeesHexZod = object$3({
-  base: HexZod,
-  gasLimit: HexZod,
-  gasPrice: HexZod,
-  priority: HexZod
-});
-var TransactionFeesBigIntZod = object$3({
-  base: AttoZod,
-  gasLimit: AttoZod,
-  gasPrice: AttoZod,
-  priority: AttoZod
-});
-TransactionFeesHexZod.transform((val) => ({
-  base: JsonToBigIntZod.parse(val.base),
-  gasLimit: JsonToBigIntZod.parse(val.gasLimit),
-  gasPrice: JsonToBigIntZod.parse(val.gasPrice),
-  priority: JsonToBigIntZod.parse(val.priority)
-}));
-TransactionFeesBigIntZod.transform((val) => ({
-  base: BigIntToJsonZod.parse(val.base),
-  gasLimit: BigIntToJsonZod.parse(val.gasLimit),
-  gasPrice: BigIntToJsonZod.parse(val.gasPrice),
-  priority: BigIntToJsonZod.parse(val.priority)
-}));
-
-// src/zod/TransactionBoundWitness.ts
-object$3({
-  nbf: BlockNumberZod
-});
-object$3({
-  exp: BlockNumberZod
-});
-var BlockDurationZod = object$3({
-  nbf: BlockNumberZod,
-  exp: BlockNumberZod
-});
-var BlockScriptsZod = object$3({
-  script: array$1(string$2()).optional()
-});
-var WithTransactionFeesZod = object$3({
-  fees: TransactionFeesHexZod
-});
-var TransactionBoundWitnessFields = object$3({
-  chain: ChainZod,
-  from: ChainZod
-});
-var TransactionBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod);
-var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod.partial());
-
-// src/zod/HydratedTransaction.ts
-tuple([
-  TransactionBoundWitnessZod,
-  array$1(PayloadZodLoose)
-]);
-var UnsignedHydratedTransactionZod = tuple([
-  TransactionBoundWitnessZod,
-  array$1(PayloadZodLoose)
-]);
-var SignedHydratedTransactionZod = tuple([
-  SignedTransactionBoundWitnessZod,
-  array$1(PayloadZodLoose)
-]);
-SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
-  tx,
-  payloads.map((payload) => payload)
-]));
-SignedHydratedTransactionZod.transform(([tx, payloads]) => [
-  asSignedHydratedTransaction(tx),
-  payloads.map((p) => asAnyPayload(p))
-]);
-var CaveatTypesZod = _enum$1([
-  "chain",
-  "expiration",
-  "filteredResponse",
-  "rateLimit",
-  "restrictReturnedAccounts"
-]);
-var CaveatsZod = object$3({
-  type: CaveatTypesZod,
-  value: json$3()
-});
-var PermissionZod = object$3({
-  parentCapability: string$2(),
-  caveats: CaveatsZod.array().optional(),
-  invoker: string$2()
-});
-var InvokerPermissionZod = PermissionZod.extend({
-  date: number$3().optional()
-});
-var PermissionRequestZod = record$1(string$2(), record$1(string$2(), any$1()));
-var RequestedPermissionZod = object$3({
-  parentCapability: string$2(),
-  date: number$3().optional()
-});
-var RewardsRangeOptionsZod = object$3({
-  positions: array$1(number$3()).optional(),
-  range: BlockRangeZod.optional(),
-  steps: array$1(StepIdentityZod).optional(),
-  stakers: array$1(AddressZod).optional()
-});
-var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = string$2().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = string$2().regex(LocalSequenceRegex).transform((v) => toHex(v));
-var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = string$2().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = string$2().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-union$1([
-  LocalSequenceToStringZod,
-  QualifiedSequenceToStringZod
-]);
-union$1([
-  LocalSequenceFromStringZod,
-  QualifiedSequenceFromStringZod
-]);
-var StakeZod = object$3({
-  amount: AttoZod,
-  // the block number when the stake was added
-  addBlock: number$3(),
-  // the unique id for the stake item
-  id: number$3(),
-  // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: number$3(),
-  // the address that is being staked
-  staked: AddressZod,
-  // the address that owns the stake
-  staker: AddressZod,
-  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: number$3()
-});
-var StakeToJsonZod = StakeZod.transform((val) => ({
-  addBlock: val.addBlock,
-  amount: AttoToJsonZod.parse(val.amount),
-  id: val.id,
-  removeBlock: val.removeBlock,
-  staked: AddressZod.parse(val.staked),
-  staker: AddressZod.parse(val.staker),
-  withdrawBlock: val.withdrawBlock
-}));
-var JsonToStakeZod = StakeZod.extend({
-  amount: HexZod
-}).transform((val) => ({
-  addBlock: val.addBlock,
-  amount: JsonToAttoZod.parse(val.amount),
-  id: val.id,
-  removeBlock: val.removeBlock,
-  staked: val.staked,
-  staker: val.staker,
-  withdrawBlock: val.withdrawBlock
-}));
-var TimeDomainZod = union$1([
-  literal$2("xl1"),
-  literal$2("epoch"),
-  literal$2("ethereum")
-]);
-var TransferPairZod = z.tuple([
-  AddressZod,
-  AddressZod
-]);
-
-// src/viewers/AccountBalance.ts
 var AccountBalanceHistoryItemZod = z.tuple([
   WithHashMetaZod(BlockBoundWitnessZod),
   WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
   WithHashMetaZod(TransferZod)
 ]);
+var PendingTransactionsOptionsZod = z.object({
+  cursor: HashZod.optional(),
+  limit: z.number().int().positive().optional(),
+  window: XL1BlockRangeZod.optional()
+});
 
 // src/wallet/paths.ts
 var WALLET_COMPLIANCE = "44'";
@@ -84265,7 +84265,7 @@ async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainS
   return await buildBlock({
     chainId: previousBlock.chain,
     previousBlockNumber: previousBlock.block,
-    previousStepHashes: previousBlock.step_hashes,
+    previousStepHashes: previousBlock.step_hashes ?? [],
     previousBlockHash: previousBlock._hash,
     txs,
     blockPayloads,
@@ -84293,14 +84293,14 @@ __name$j(buildNextBlock, "buildNextBlock");
     const chain = assertEx(this._chain, () => "Chain must be set before building the transaction");
     const fees = assertEx(this._fees, () => "Fees must be set before building the transaction");
     const blockRange = assertEx(this._blockRange, () => "Block range must be set before building the transaction");
-    return await buildTransaction(chain, this._elevatedPayloads, this._payloads, this._signers, blockRange[0], blockRange[1], this._signers[0]?.address, fees);
+    return await buildTransaction(chain, this._elevatedPayloads, this._payloads, this._signers, asXL1BlockNumber(blockRange[0], true), asXL1BlockNumber(blockRange[1], true), this._signers[0]?.address, fees);
   }
   chain(chain) {
     this._chain = chain;
     return this;
   }
   async dryRun() {
-    return await buildTransaction(XYO_ZERO_ADDRESS, this._elevatedPayloads, this._payloads, this._signers, 0, 1e3, this._signers[0]?.address, defaultTransactionFees);
+    return await buildTransaction(XYO_ZERO_ADDRESS, this._elevatedPayloads, this._payloads, this._signers, asXL1BlockNumber(0, true), asXL1BlockNumber(1e3, true), this._signers[0]?.address, defaultTransactionFees);
   }
   elevatedPayload(payload) {
     const allowedPayload = isAllowedBlockPayload(payload) ? payload : void 0;
@@ -84384,19 +84384,19 @@ __name$j(buildNextBlock, "buildNextBlock");
   }
 });
 assertEx(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
-function createProducerChainStakeIntent(from, exp, nbf = 0) {
-  return new PayloadBuilder({
+async function createProducerChainStakeIntent(from, exp, nbf = 0) {
+  return await PayloadBuilder.addHashMeta(new PayloadBuilder({
     schema: ChainStakeIntentSchema
   }).fields({
     from,
     exp,
     nbf,
     intent: "producer"
-  }).build();
+  }).build());
 }
 __name$j(createProducerChainStakeIntent, "createProducerChainStakeIntent");
-async function createProducerChainStakeIntentTransaction(chain, signers = [], producer, exp, nbf = 0, fees = defaultTransactionFees) {
-  const intent = createProducerChainStakeIntent(producer, exp, nbf);
+async function createProducerChainStakeIntentTransaction(chain, signers = [], producer, exp, nbf = asXL1BlockNumber(0, true), fees = defaultTransactionFees) {
+  const intent = await createProducerChainStakeIntent(producer, exp, nbf);
   const tx = await buildTransaction(chain, [
     intent
   ], [], signers, nbf, exp, signers[0].address, fees);
@@ -84406,7 +84406,7 @@ __name$j(createProducerChainStakeIntentTransaction, "createProducerChainStakeInt
 
 // src/block/createGenesisBlock.ts
 var createGenesisBlock = /* @__PURE__ */ __name$j(async (initialBlockProducer, nextContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
-  const blockPayloads = [
+  const blockPayloads = await PayloadBuilder.addHashMeta([
     TransferPayloadJsonSchemaPayload,
     BlockBoundWitnessSchemaPayload,
     BlockBoundWitnessWithStorageMetaSchemaPayload,
@@ -84414,13 +84414,13 @@ var createGenesisBlock = /* @__PURE__ */ __name$j(async (initialBlockProducer, n
     TransactionBoundWitnessWithStorageMetaSchemaPayload,
     ChainStakeIntentPayloadJsonSchemaPayload,
     HashPayloadJsonSchemaPayload
-  ];
-  const intentPayload = createProducerChainStakeIntent(initialBlockProducer.address, 1, 0);
+  ]);
+  const intentPayload = await createProducerChainStakeIntent(initialBlockProducer.address, 1, 0);
   blockPayloads.push(intentPayload);
   if (genesisBlockRewardAmount > 0n) {
-    blockPayloads.push(createTransferPayload(nextContractAddress, {
+    blockPayloads.push(await PayloadBuilder.addHashMeta(createTransferPayload(nextContractAddress, {
       [genesisBlockRewardAddress]: genesisBlockRewardAmount
-    }));
+    })));
   }
   return await buildGenesisBlock(nextContractAddress, [], blockPayloads, [
     initialBlockProducer
@@ -84657,12 +84657,12 @@ async function frameList(block, archivist) {
     let blockToCheck = block;
     const stepHashes = [];
     while (blockToCheck) {
-      let stepHash = blockToCheck.step_hashes.at(stepIndex);
+      let stepHash = blockToCheck.step_hashes?.at(stepIndex);
       if (stepHash === void 0) {
         break;
       } else {
         for (const [i, brk] of breaks.entries()) {
-          if (brk === blockToCheck.step_hashes.at(i)) {
+          if (brk === blockToCheck.step_hashes?.at(i)) {
             break;
           }
         }
@@ -84744,7 +84744,7 @@ var findMostRecentBlock = /* @__PURE__ */ __name$j(async (chainArchivist, nextOp
       order: "desc",
       cursor
     });
-    const blocks = batch.filter(isBlockBoundWitnessWithStorageMeta);
+    const blocks = batch.filter(isSignedBlockBoundWitnessWithStorageMeta);
     const last = blocks?.at(0);
     if (last) {
       mostRecentBlock = last;
@@ -85162,7 +85162,7 @@ var analyzeChain = /* @__PURE__ */ __name$i(async (store, handlers, head, previo
     let maxDepthLimit = maxDepth === -1n ? BigInt(Number.MAX_SAFE_INTEGER) : maxDepth;
     let cursor = typeof head === "string" ? await hydrateBlock(store, head) : head;
     logger?.log("analyzeChain.cursor", cursor?.[0].block);
-    if (previousHead !== null && cursor[0]._hash === previousHead) return [];
+    if (previousHead !== null && cursor?.[0]._hash === previousHead) return [];
     while (cursor && maxDepthLimit > 0n) {
       maxDepthLimit -= 1n;
       await analyzeBlock(cursor, handlers);
@@ -85187,7 +85187,6 @@ var analyzeChain = /* @__PURE__ */ __name$i(async (store, handlers, head, previo
   }, tracer), () => "analyzeChain failed");
 }, "analyzeChain");
 var ChainSummaryBalancesSchema = "network.xyo.chain.summary.balances";
-var isChainSummaryBalances = isPayloadOfSchemaType(ChainSummaryBalancesSchema);
 
 // src/BalanceAnalyzer/BalanceAnalyzer.ts
 var bigintBalances = /* @__PURE__ */ __name$i((balances) => {
@@ -85271,7 +85270,7 @@ var ChainFinalizer = class extends Base {
   }
   async finalizeBlock(hash) {
     return await spanRootAsync("finalizeBlock", async () => {
-      const blockToFinalize = assertEx(asBlockBoundWitnessWithStorageMeta((await this.chainArchivist.get([
+      const blockToFinalize = assertEx(asSignedBlockBoundWitnessWithStorageMeta((await this.chainArchivist.get([
         hash
       ]))[0], () => `Block not found [${hash}]`));
       const blockNumberToFinalize = blockToFinalize.block;
@@ -85292,7 +85291,7 @@ var ChainFinalizer = class extends Base {
           this.finalizedBlockNumber = blockNumberToFinalize;
           return;
         } else {
-          blockToCheck = assertEx(asBlockBoundWitnessWithStorageMeta((await this.chainArchivist.get([
+          blockToCheck = assertEx(asSignedBlockBoundWitnessWithStorageMeta((await this.chainArchivist.get([
             blockToCheck.previous
           ]))[0], () => `Block not found [${hash}]`));
           const newBlockNumber = blockToCheck.block;
@@ -85408,7 +85407,7 @@ var ChainHeadSelector = class extends ChainFinalizer {
         open: true
       });
       while (results.length > 0) {
-        const blocks = results.filter(isBlockBoundWitnessWithStorageMeta);
+        const blocks = results.filter(isSignedBlockBoundWitnessWithStorageMeta);
         newBlocks.push(...blocks);
         const lastResult = assertEx(results.at(-1));
         results = await this.chainArchivist.next({
@@ -93063,7 +93062,7 @@ var BoundWitnessSignaturesValidator = /* @__PURE__ */ __name$h(async (bw) => {
     const results = await Promise.all(bw.addresses.map(async (address, index) => {
       return [
         address,
-        await BoundWitnessValidator.validateSignature(toArrayBuffer(dataHash), toArrayBuffer(address), toArrayBuffer(bw.$signatures[index]))
+        await BoundWitnessValidator.validateSignature(toArrayBuffer(dataHash), toArrayBuffer(address), toArrayBuffer(bw.$signatures[index] ?? void 0))
       ];
     }));
     for (const [, bwErrors] of results) {
@@ -94217,7 +94216,7 @@ var BlockValidationDiviner = class extends AbstractDiviner {
   async divineHandler(payloads) {
     const inArchivist = await this.resolveInArchivist();
     const inMap = readPayloadMapFromStore(inArchivist);
-    const blocks = (payloads ?? []).map(asBlockBoundWitness).filter(exists$1);
+    const blocks = (payloads ?? []).map((b) => asBlockBoundWitness(b)).filter(exists$1);
     const results = (await Promise.all(blocks.map(async (block) => {
       const blockHash = await PayloadBuilder.hash(block);
       const hydratedBlock = await hydrateBlock({
@@ -94256,6 +94255,7 @@ var HeadValidationDiviner = class extends AbstractDiviner {
     HeadValidationDivinerConfigSchema
   ];
   static targetSchema = HeadValidationDivinerConfigSchema;
+  _headValidationDivinerHeadUpdateTotal;
   _headSelector;
   _inArchivist;
   _outArchivist;
@@ -94270,6 +94270,12 @@ var HeadValidationDiviner = class extends AbstractDiviner {
   get headSelector() {
     return assertEx(this._headSelector, () => "Missing head selector");
   }
+  async createHandler() {
+    await super.createHandler();
+    this._headValidationDivinerHeadUpdateTotal = this.meter?.createCounter("head_validation_diviner_head_update_total", {
+      description: "Count of head updates performed by the diviner during head validation"
+    });
+  }
   async initializeHeadSelector() {
     return await spanRootAsync("initializeHeadSelector", async () => {
       if (!this._headSelector) {
@@ -94280,7 +94286,7 @@ var HeadValidationDiviner = class extends AbstractDiviner {
           const payload = await outArchivist.get([
             this.config.finalizedBlock
           ]);
-          const blocks = filterAs(payload, asBlockBoundWitnessWithStorageMeta);
+          const blocks = payload.filter(isSignedBlockBoundWitnessWithStorageMeta);
           const block = blocks.at(0);
           if (block) finalizedBlock = block;
         } else {
@@ -94301,9 +94307,9 @@ var HeadValidationDiviner = class extends AbstractDiviner {
           }
         }
         if (isDefined(finalizedBlock)) {
-          this._startingHead = filterAs(await inArchivist.get([
+          this._startingHead = (await inArchivist.get([
             finalizedBlock._hash
-          ]), asBlockBoundWitnessWithStorageMeta).at(0);
+          ])).find(isSignedBlockBoundWitnessWithStorageMeta);
           if (isDefined(this._startingHead)) {
             this._headSelector = new ChainHeadSelector({
               allowedProducers: this.allowedProducers,
@@ -94344,6 +94350,7 @@ var HeadValidationDiviner = class extends AbstractDiviner {
             const inMap = readPayloadMapFromStore(inArchivist);
             let currentBlockHash = headBlock._hash;
             let payloadsToFinalize = [];
+            let finalizedBlocksAttributes = [];
             this.logger?.debug("Validating new HeadBlock head from (block) ", headBlock.block, "to", this._startingHead?.block);
             this.logger?.debug("Validating new HeadBlock head from (hash) ", headBlock._hash, "to", this._startingHead?._hash);
             const start = Date.now();
@@ -94367,6 +94374,12 @@ var HeadValidationDiviner = class extends AbstractDiviner {
                 ...flattenHydratedBlock(hydratedBlock),
                 ...payloadsToFinalize
               ];
+              finalizedBlocksAttributes = [
+                {
+                  producer: hydratedBlock[0].addresses[0]
+                },
+                ...finalizedBlocksAttributes
+              ];
               currentBlockHash = hydratedBlock[0].previous;
             }
             if (headBlock._hash !== this._startingHead?._hash) {
@@ -94374,14 +94387,18 @@ var HeadValidationDiviner = class extends AbstractDiviner {
               this.logger?.info("Validated new HeadBlock head from (hash) in", `${Date.now() - start}ms`, headBlock._hash, "to", this._startingHead?._hash);
             }
             await spanRootAsync("HeadValidationDiviner:commitToOutArchivist", async () => {
-              if (payloadsToFinalize.length > 0) await outArchivist.insert(payloadsToFinalize);
+              if (payloadsToFinalize.length > 0) {
+                await outArchivist.insert(payloadsToFinalize);
+                for (const finalizedBlockAttributes of finalizedBlocksAttributes) {
+                  this._headValidationDivinerHeadUpdateTotal?.add(1, finalizedBlockAttributes);
+                }
+              }
             }, this.tracer);
             this.headSelector.unsafeFinalizeBlock(headBlock);
             this._startingHead = headBlock;
             return payloadsToFinalize;
           } else {
             this.logger?.info("No head found to validate", this._startingHead?._hash);
-            return [];
           }
         } catch (ex) {
           this.logger?.error("Error in divineHandler", ex);
@@ -94567,7 +94584,7 @@ var createSignatureWrappers = /* @__PURE__ */ __name$e(async (bw) => {
   const signatures = [];
   const hash = await PayloadBuilder.dataHash(bw);
   for (let i = 0; i < bw.$signatures.length; i++) {
-    signatures.push(new SignatureWrapper(bw.$signatures[i], bw.addresses[i], hash));
+    signatures.push(new SignatureWrapper(asHex(bw.$signatures[i], true), bw.addresses[i], hash));
   }
   return signatures;
 }, "createSignatureWrappers");
@@ -116876,62 +116893,6 @@ function creatableService() {
   };
 }
 __name$b(creatableService, "creatableService");
-function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist) {
-  const result = {
-    blockByHash: /* @__PURE__ */ __name$b(async function(hash) {
-      const [payload] = await chainArchivist.get([
-        hash
-      ]);
-      const block = asBlockBoundWitnessWithStorageMeta(payload);
-      if (isDefined(block)) {
-        const payloads = await chainArchivist.get(block.payload_hashes);
-        return [
-          block,
-          payloads
-        ];
-      }
-      return null;
-    }, "blockByHash"),
-    blockByNumber: /* @__PURE__ */ __name$b(async function(blockNumber) {
-      const payload = await chainIterator.get(blockNumber);
-      const block = payload ? await PayloadBuilder.addStorageMeta(payload) : void 0;
-      if (isDefined(block)) {
-        const payloads = await chainArchivist.get(block.payload_hashes);
-        return [
-          block,
-          payloads
-        ];
-      }
-      return null;
-    }, "blockByNumber"),
-    blocksByHash: /* @__PURE__ */ __name$b(async function(hash, limit = 10) {
-      const results = [];
-      for (let i = 0; i < limit; i++) {
-        const block = await this.blockByHash(hash);
-        if (block) {
-          results.push(block);
-        } else {
-          break;
-        }
-      }
-      return results;
-    }, "blocksByHash"),
-    currentBlock: /* @__PURE__ */ __name$b(async function() {
-      const head = await chainIterator.head();
-      return this.blockByHash(head._hash);
-    }, "currentBlock"),
-    currentBlockHash: /* @__PURE__ */ __name$b(async function() {
-      const head = await chainIterator.head();
-      return head._hash;
-    }, "currentBlockHash"),
-    currentBlockNumber: /* @__PURE__ */ __name$b(async function() {
-      const head = await chainIterator.head();
-      return head.block;
-    }, "currentBlockNumber")
-  };
-  return result;
-}
-__name$b(blockViewerFromChainIteratorAndArchivist, "blockViewerFromChainIteratorAndArchivist");
 
 // src/AccountBalance/BaseAccountBalanceService.ts
 function _ts_decorate2$1(decorators, target, key, desc) {
@@ -116941,24 +116902,48 @@ function _ts_decorate2$1(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name$b(_ts_decorate2$1, "_ts_decorate");
+var BaseAccountBalanceServiceParamsZod = z.object({
+  blockViewer: z.object().loose(),
+  chainArchivist: z.object().loose(),
+  chainIterator: z.object().loose(),
+  context: z.object().loose(),
+  transferContext: z.object().loose()
+});
 var BaseAccountBalanceService = class extends BaseService {
   static {
     __name$b(this, "BaseAccountBalanceService");
   }
   accountBalanceViewer;
-  blockViewer;
+  get blockViewer() {
+    return assertEx(this.params.blockViewer, () => "BlockViewer has not been initialized yet");
+  }
+  static async paramsHandler(params) {
+    BaseAccountBalanceServiceParamsZod.parse(params);
+    assertEx(params?.context?.head, () => "BalanceStepSummaryContext is required in BaseAccountBalanceServiceParams");
+    return {
+      ...await super.paramsHandler(params),
+      ...params
+    };
+  }
   async accountBalance(address, headOrRange) {
-    const balances = await this.accountBalances([
+    const balances = await this.accountsBalances([
       address
     ], headOrRange);
     return balances[address] ?? AttoXL1(0n);
   }
-  async accountBalanceHistory(address, headOrRange) {
-    return await this.accountBalanceViewer.accountBalanceHistory(address, headOrRange);
+  accountBalanceHistory(_address, _headOrRange) {
+    throw new Error("Method not implemented.");
   }
-  async accountBalances(address, _headOrRange) {
+  async accountsBalances(address, _headOrRange) {
     return await spanRootAsync("balances", async () => {
-      const summary = await balancesSummary(this.params.context);
+      const context = {
+        head: this.params.context.head,
+        stepSemaphores: this.params.context.stepSemaphores,
+        store: this.params.context.store,
+        chainId: this.params.context.chainId,
+        summaryMap: this.params.context.summaryMap
+      };
+      const summary = await balancesSummary(context);
       const result = {};
       for (const addr of address) {
         const summaryBalance = summary[addr] ?? 0n;
@@ -116967,15 +116952,15 @@ var BaseAccountBalanceService = class extends BaseService {
       return result;
     });
   }
-  accountsBalances(address, headOrRange) {
+  accountsBalancesHistory(_addresses, _headOrRange) {
     throw new Error("Method not implemented.");
   }
-  async accountsBalancesHistory(addresses, headOrRange) {
-    return await this.accountBalanceViewer.accountsBalancesHistory(addresses, headOrRange);
-  }
-  createHandler() {
-    this.blockViewer = blockViewerFromChainIteratorAndArchivist(this.params.chainIterator, this.params.chainArchivist);
-    this.accountBalanceViewer = new SimpleAccountBalanceViewer(this.params.context, this.params.transferContext, this.blockViewer);
+  async createHandler() {
+    this.accountBalanceViewer = await SimpleAccountBalanceViewer.create({
+      context: this.params.context,
+      transferContext: this.params.transferContext,
+      blockViewer: this.blockViewer
+    });
   }
 };
 BaseAccountBalanceService = _ts_decorate2$1([
@@ -117060,6 +117045,13 @@ __name$b(_ts_decorate4, "_ts_decorate");
 var DEFAULT_BLOCK_SIZE = 10;
 var XYO_PRODUCER_REDECLARATION_DURATION = 1e4;
 var XYO_PRODUCER_REDECLARATION_WINDOW = 500;
+var BaseBlockProducerServiceParamsZod = z.object({
+  balanceService: z.object().loose(),
+  pendingTransactionsService: z.object().loose(),
+  rejectedTransactionsArchivist: z.object().loose(),
+  rewardAddress: AddressZod,
+  time: z.object().loose()
+});
 var BaseBlockProducerService = class _BaseBlockProducerService extends BaseService {
   static {
     __name$b(this, "BaseBlockProducerService");
@@ -117124,6 +117116,13 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   get validateHydratedBlockState() {
     return assertEx(this.params.validateHydratedBlockState, () => "validateHydratedBlockState is required");
   }
+  static async paramsHandler(params) {
+    BaseBlockProducerServiceParamsZod.parse(params);
+    return {
+      ...await super.paramsHandler(params),
+      ...params
+    };
+  }
   async next(head) {
     if (head.chain !== this.chainId) return;
     const leadersStart = Date.now();
@@ -117386,6 +117385,62 @@ var MemoryBlockRewardService = class extends BaseBlockRewardService {
 MemoryBlockRewardService = _ts_decorate7([
   creatable()
 ], MemoryBlockRewardService);
+function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist) {
+  const result = {
+    blockByHash: /* @__PURE__ */ __name$b(async function(hash) {
+      const [payload] = await chainArchivist.get([
+        hash
+      ]);
+      const block = asSignedBlockBoundWitnessWithStorageMeta(payload);
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes);
+        return [
+          block,
+          payloads
+        ];
+      }
+      return null;
+    }, "blockByHash"),
+    blockByNumber: /* @__PURE__ */ __name$b(async function(blockNumber) {
+      const payload = asSignedBlockBoundWitness(await chainIterator.get(blockNumber));
+      const block = payload ? await PayloadBuilder.addHashMeta(payload) : void 0;
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes);
+        return [
+          block,
+          payloads
+        ];
+      }
+      return null;
+    }, "blockByNumber"),
+    blocksByHash: /* @__PURE__ */ __name$b(async function(hash, limit = 10) {
+      const results = [];
+      for (let i = 0; i < limit; i++) {
+        const block = await this.blockByHash(hash);
+        if (block) {
+          results.push(block);
+        } else {
+          break;
+        }
+      }
+      return results;
+    }, "blocksByHash"),
+    currentBlock: /* @__PURE__ */ __name$b(async function() {
+      const head = await chainIterator.head();
+      return this.blockByHash(head._hash);
+    }, "currentBlock"),
+    currentBlockHash: /* @__PURE__ */ __name$b(async function() {
+      const head = await chainIterator.head();
+      return head._hash;
+    }, "currentBlockHash"),
+    currentBlockNumber: /* @__PURE__ */ __name$b(async function() {
+      const head = await chainIterator.head();
+      return head.block;
+    }, "currentBlockNumber")
+  };
+  return result;
+}
+__name$b(blockViewerFromChainIteratorAndArchivist, "blockViewerFromChainIteratorAndArchivist");
 var ChainBlockNumberIterationService = class extends BaseService {
   static {
     __name$b(this, "ChainBlockNumberIterationService");
@@ -117764,12 +117819,12 @@ BaseNetworkStakeStepRewardService = _ts_decorate10([
   creatable()
 ], BaseNetworkStakeStepRewardService);
 var bundledPayloadToHydratedTransaction = /* @__PURE__ */ __name$b(async (payload) => {
-  const withStorageMeta = await PayloadBuilder.addStorageMeta(payload.payloads);
-  const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find((p) => p._hash === payload.root));
+  const withHashMeta = await PayloadBuilder.addHashMeta(payload.payloads);
+  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [
       tx,
-      withStorageMeta.filter((p) => p._hash !== payload.root)
+      withHashMeta.filter((p) => p._hash !== payload.root)
     ];
   }
 }, "bundledPayloadToHydratedTransaction");
@@ -117890,7 +117945,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
         let [lastHead] = filterAs(await this.chainArchivist.get([
           head
-        ]), asBlockBoundWitnessWithHashMeta);
+        ]), (x) => asBlockBoundWitnessWithHashMeta(x));
         if (isUndefined$1(lastHead)) return [];
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
         const foundPendingTransactions = [];
@@ -117905,7 +117960,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           cursor = pendingBundledTransactions.at(-1)?._sequence;
           const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
           const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists$1);
-          const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1));
+          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber(lastHead.block + 1, true)));
           const txValidationResults = await Promise.all(activeTransactions.map(async (tx) => [
             tx,
             await validateTransaction(tx, {
@@ -117996,7 +118051,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       let cursor;
       let [lastHead] = filterAs(await this.chainArchivist.get([
         head
-      ]), asBlockBoundWitnessWithHashMeta);
+      ]), (x) => asBlockBoundWitnessWithHashMeta(x));
       while (isDefined(lastHead)) {
         const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
           limit: 100,
@@ -118011,7 +118066,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists$1));
         const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
         const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists$1);
-        const expiredTransactions = transactions.filter(isTransactionExpired(lastHead.block + 1));
+        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber(lastHead.block + 1, true)));
         const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
           // Find the corresponding payload bundle hash for the expired transaction
           pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
@@ -118863,7 +118918,7 @@ var AbstractSentinel = class _AbstractSentinel extends AbstractModuleInstance {
   }
   async emitReportEnd(inPayloads, payloads) {
     const boundwitnesses = payloads?.filter(isBoundWitness) ?? [];
-    const outPayloads = payloads?.filter(notBoundWitness) ?? [];
+    const outPayloads = payloads?.filter((payload) => !isBoundWitness(payload)) ?? [];
     const boundwitness = boundwitnesses.find((bw) => bw.addresses.includes(this.address));
     await this.emit("reportEnd", {
       boundwitness,
@@ -121105,6 +121160,11 @@ var NodeXyoViewer = class extends AbstractCreatable {
   _signedHydratedBlockCache;
   _signedHydratedTransactionCache;
   _transferBalanceDiviner;
+  get account() {
+    return {
+      balance: this.params.accountBalanceViewer
+    };
+  }
   get context() {
     return assertEx(this.params.context, () => "NodeXyoViewer requires a context");
   }
@@ -121126,64 +121186,24 @@ var NodeXyoViewer = class extends AbstractCreatable {
       ...this.context
     };
   }
-  async accountBalance(address) {
-    return await spanRootAsync("accountBalance", async () => {
-      const diviner = await this.getAddressBalanceDiviner();
-      const query = new PayloadBuilder({
-        schema: AddressSchema
-      }).fields({
-        address
-      }).build();
-      const result = await diviner.divine([
-        query
-      ]);
-      const chainSummary = assertEx(result.find(isChainSummaryBalances), () => "Failed to divine chain summary balances");
-      const balances = chainSummary.balances;
-      const signedBalance = balances[address] === void 0 ? 0n : parseSignedBigInt(balances[address]);
-      return asAttoXL1(signedBalance > 0n ? signedBalance : 0n);
-    }, this.tracer);
+  static async paramsHandler(params) {
+    assertEx(params.accountBalanceViewer, () => "NodeXyoViewer requires an AccountBalanceViewer");
+    return {
+      ...await super.paramsHandler(params),
+      ...params
+    };
+  }
+  async accountBalance(address, rangeOrHash) {
+    return await this.account.balance.accountBalance(address, rangeOrHash);
   }
   async accountBalanceHistory(address, rangeOrHash) {
-    return await spanRootAsync("accountHistory", async () => {
-      const range = asRange(rangeOrHash);
-      const startingRange = asXL1BlockRange(range ?? [
-        0,
-        await this.currentBlockNumber()
-      ], {
-        name: "accountBalanceHistory"
-      });
-      const blockNumbers = await this.distillTransferHistory(address, startingRange);
-      const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockByNumber(bn)))).filter(exists$1);
-      const result = [];
-      for (const block of blocks) {
-        const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : void 0).filter(exists$1);
-        const transfers = transferIndexes.map((index) => {
-          const hash = block[0].payload_hashes[index];
-          return assertEx(block[1].find((p) => p._hash === hash), () => `Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
-        }).filter(exists$1).filter((t) => t.from === address || isDefined(t.transfers[address]));
-        if (transfers.length === 0) {
-          continue;
-        }
-        const pairs = transfers.map((transfer) => {
-          return [
-            block[0],
-            transfer
-          ];
-        });
-        result.push(...pairs.map(([block2, transfer]) => [
-          block2,
-          null,
-          transfer
-        ]));
-      }
-      return result;
-    }, this.tracer);
+    return await this.account.balance.accountBalanceHistory(address, rangeOrHash);
   }
-  accountsBalances(address, headOrRange) {
-    throw new Error("Method not implemented.");
+  async accountsBalances(addresses, headOrRange) {
+    return await this.account.balance.accountsBalances(addresses, headOrRange);
   }
-  accountsBalancesHistory(address, headOrRange) {
-    throw new Error("Method not implemented.");
+  async accountsBalancesHistory(addresses, headOrRange) {
+    return await this.account.balance.accountsBalancesHistory(addresses, headOrRange);
   }
   async blockByHash(hash) {
     return await spanRootAsync("blockByHash", async () => {
@@ -121193,7 +121213,7 @@ var NodeXyoViewer = class extends AbstractCreatable {
   }
   async blockByNumber(blockNumber) {
     return await spanRootAsync("blockByNumber", async () => {
-      return await hydratedBlockByNumber(this.context, blockNumber);
+      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(this.context, blockNumber)) ?? null;
     }, this.tracer);
   }
   async blocksByHash(hash, limit = 10) {
@@ -121208,7 +121228,7 @@ var NodeXyoViewer = class extends AbstractCreatable {
         if (previousHash === null) break;
         current = await this.blockByHash(previousHash);
       }
-      return blocks;
+      return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
     }, this.tracer);
   }
   async chainId() {
@@ -121547,7 +121567,12 @@ var NodeXyoViewer = class extends AbstractCreatable {
   async getHydratedBlockCache() {
     if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
     const chainMap = await this.getFinalizedPayloadMap();
-    this._signedHydratedBlockCache = new HydratedCache(chainMap, hydrateBlock, 200);
+    this._signedHydratedBlockCache = new HydratedCache(chainMap, async ({ chainMap: chainMap2 }, hash, maxDepth, minDepth) => {
+      const result = await hydrateBlock({
+        chainMap: chainMap2
+      }, hash, maxDepth, minDepth);
+      return asSignedHydratedBlockWithHashMeta(result, true);
+    }, 200);
     return this._signedHydratedBlockCache;
   }
   async getHydratedTransactionCache() {
@@ -268159,7 +268184,7 @@ var BoundWitnessDivinerSchema = "network.xyo.diviner.boundwitness";
 
 // src/Config.ts
 var BoundWitnessDivinerConfigSchema = `${BoundWitnessDivinerSchema}.config`;
-var BoundWitnessDivinerQuerySchema = `${BoundWitnessDivinerSchema}.query`;
+var BoundWitnessDivinerQuerySchema = asSchema(`${BoundWitnessDivinerSchema}.query`, true);
 var isBoundWitnessDivinerQueryPayload = isPayloadOfSchemaType(BoundWitnessDivinerQuerySchema);
 
 // src/Diviner.ts
@@ -268173,7 +268198,6 @@ var applyBoundWitnessDivinerQueryPayload = (filter, payloads = []) => {
   if (!filter) return [];
   const {
     addresses,
-    block,
     cursor,
     destination,
     limit,
@@ -268187,7 +268211,7 @@ var applyBoundWitnessDivinerQueryPayload = (filter, payloads = []) => {
   const parsedOffset = order === "desc" ? sortedPayloads.findIndex((bw) => bw._sequence < parsedCursor) : sortedPayloads.findIndex((bw) => bw._sequence > parsedCursor);
   if (parsedOffset === -1) return [];
   const payloadSubset = sortedPayloads.slice(parsedOffset);
-  let bws = filterAs(payloadSubset, asOptionalBoundWitness);
+  let bws = payloadSubset.filter(isBoundWitness);
   const allAddresses = addresses?.map((address) => hexFromHexString(address)).filter(exists$1);
   if (allAddresses?.length) bws = bws.filter((bw) => containsAll(bw.addresses, allAddresses));
   if (payload_hashes?.length) bws = bws.filter((bw) => containsAll(bw.payload_hashes, payload_hashes));
@@ -268200,9 +268224,6 @@ var applyBoundWitnessDivinerQueryPayload = (filter, payloads = []) => {
       return targetDestinationField !== void 0 && Array.isArray(targetDestinationField) && targetDestinationField.length > 0 ? containsAll(targetFilter, targetDestinationField ?? []) : false;
     });
   }
-  if (block !== void 0) {
-    bws = order === "desc" ? filterAs(bws, asBlock).filter((bw) => bw.block <= block) : filterAs(bws, asBlock).filter((bw) => bw.block >= block);
-  }
   const parsedLimit = limit ?? bws.length;
   return bws.slice(0, parsedLimit);
 };
@@ -268211,7 +268232,7 @@ var MemoryBoundWitnessDiviner = class extends BoundWitnessDiviner {
     const filter = assertEx(payloads?.filter(isBoundWitnessDivinerQueryPayload)?.pop(), () => "Missing query payload");
     if (!filter) return [];
     const archivist = assertEx(await this.archivistInstance(), () => "Unable to resolve archivist");
-    let bws = (await archivist?.next({ limit: 1e4 }) ?? []).filter(isBoundWitnessWithStorageMeta);
+    let bws = (await archivist?.next({ limit: 1e4 }) ?? []).filter((x) => isBoundWitness(x) && isStorageMeta(x));
     return applyBoundWitnessDivinerQueryPayload(filter, bws);
   }
 };
@@ -269399,6 +269420,7 @@ async function initSeedPhrase({ config, logger, bios }) {
 __name$6(initSeedPhrase, "initSeedPhrase");
 var getLocator$2 = /* @__PURE__ */ __name$6(async ({ config, logger, balanceSummaryMap, transferSummaryMap }) => {
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9465 } = config.telemetry?.metrics?.scrape ?? {};
   const { traceProvider, meterProvider } = await initTelemetry({
     attributes: {
       serviceName: "xl1-api",
@@ -269406,8 +269428,8 @@ var getLocator$2 = /* @__PURE__ */ __name$6(async ({ config, logger, balanceSumm
     },
     otlpEndpoint,
     metricsConfig: {
-      endpoint: "/metrics",
-      port: 9465
+      endpoint,
+      port
     }
   });
   if (isDefined(logger)) AbstractModule.defaultLogger = logger;
@@ -269946,6 +269968,30 @@ async function initTransferSummaryMap$1({ config, logger }) {
   }
 }
 __name$6(initTransferSummaryMap$1, "initTransferSummaryMap");
+var chainIteratorServiceSingleton;
+var stakeIntentServiceSingleton;
+var electionServiceSingleton;
+var initChainIterator = /* @__PURE__ */ __name$6((params) => {
+  if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton;
+  return timeBudget("initChainIterator", params.logger, () => {
+    chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
+    return chainIteratorServiceSingleton;
+  }, 2e3, true);
+}, "initChainIterator");
+var initStakeIntentService = /* @__PURE__ */ __name$6((params) => {
+  if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
+  return timeBudget("initStakeIntentService", params.logger, () => {
+    stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
+    return stakeIntentServiceSingleton;
+  }, 2e3, true);
+}, "initStakeIntentService");
+var initElectionService = /* @__PURE__ */ __name$6((params) => {
+  if (electionServiceSingleton) return electionServiceSingleton;
+  return timeBudget("initElectionService", params.logger, () => {
+    electionServiceSingleton = BaseElectionService.create(params);
+    return electionServiceSingleton;
+  }, 2e3, true);
+}, "initElectionService");
 
 var __defProp$6 = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -293289,12 +293335,12 @@ function requireTruncation () {
 	return truncation;
 }
 
-var stringify = {exports: {}};
+var stringify$1 = {exports: {}};
 
 var hasRequiredStringify$1;
 
 function requireStringify$1 () {
-	if (hasRequiredStringify$1) return stringify.exports;
+	if (hasRequiredStringify$1) return stringify$1.exports;
 	hasRequiredStringify$1 = 1;
 	(function (module, exports$1) {
 		exports$1 = module.exports = stringify;
@@ -293324,8 +293370,8 @@ function requireStringify$1 () {
 		    return replacer == null ? value : replacer.call(this, key, value)
 		  }
 		} 
-	} (stringify, stringify.exports));
-	return stringify.exports;
+	} (stringify$1, stringify$1.exports));
+	return stringify$1.exports;
 }
 
 var transport;
@@ -361331,72 +361377,6 @@ function requireExpress () {
 var expressExports = requireExpress();
 var express2 = /*@__PURE__*/getDefaultExportFromCjs(expressExports);
 
-/**
- * JsonRpcEngine only accepts callback-based middleware directly.
- * createAsyncMiddleware exists to enable consumers to pass in async middleware
- * functions.
- *
- * Async middleware have no "end" function. Instead, they "end" if they return
- * without calling "next". Rather than passing in explicit return handlers,
- * async middleware can simply await "next", and perform operations on the
- * response object when execution resumes.
- *
- * To accomplish this, createAsyncMiddleware passes the async middleware a
- * wrapped "next" function. That function calls the internal JsonRpcEngine
- * "next" function with a return handler that resolves a promise when called.
- *
- * The return handler will always be called. Its resolution of the promise
- * enables the control flow described above.
- *
- * @param asyncMiddleware - The asynchronous middleware function to wrap.
- * @returns The wrapped asynchronous middleware function, ready to be consumed
- * by JsonRpcEngine.
- */
-function createAsyncMiddleware(asyncMiddleware) {
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    return async (request, response, next, end) => {
-        // nextPromise is the key to the implementation
-        // it is resolved by the return handler passed to the
-        // "next" function
-        let resolveNextPromise;
-        const nextPromise = new Promise((resolve) => {
-            resolveNextPromise = resolve;
-        });
-        let returnHandlerCallback = null;
-        let nextWasCalled = false;
-        // This will be called by the consumer's async middleware.
-        const asyncNext = async () => {
-            nextWasCalled = true;
-            // We pass a return handler to next(). When it is called by the engine,
-            // the consumer's async middleware will resume executing.
-            next((runReturnHandlersCallback) => {
-                // This callback comes from JsonRpcEngine._runReturnHandlers
-                returnHandlerCallback = runReturnHandlersCallback;
-                resolveNextPromise();
-            });
-            return nextPromise;
-        };
-        try {
-            await asyncMiddleware(request, response, asyncNext);
-            if (nextWasCalled) {
-                await nextPromise; // we must wait until the return handler is called
-                returnHandlerCallback(null);
-            }
-            else {
-                end(null);
-            }
-        }
-        catch (error) {
-            if (returnHandlerCallback) {
-                returnHandlerCallback(error);
-            }
-            else {
-                end(error);
-            }
-        }
-    };
-}
-
 /**
  * A `StructFailure` represents a single specific failure in validation.
  */
@@ -363041,6 +363021,16 @@ class SafeEventEmitter extends EventEmitter {
     }
 }
 
+/**
+ * JSON-stringifies a value.
+ *
+ * @param value - The value to stringify.
+ * @returns The stringified value.
+ */
+function stringify(value) {
+    return JSON.stringify(value, null, 2);
+}
+
 var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -363056,7 +363046,10 @@ var _JsonRpcEngine_instances, _a, _JsonRpcEngine_isDestroyed, _JsonRpcEngine_mid
 const DESTROYED_ERROR_MESSAGE = 'This engine is destroyed and can no longer be used.';
 /**
  * A JSON-RPC request and response processor.
+ *
  * Give it a stack of middleware, pass it requests, and get back responses.
+ *
+ * @deprecated Use `JsonRpcEngineV2` instead.
  */
 class JsonRpcEngine extends SafeEventEmitter {
     /**
@@ -363169,13 +363162,14 @@ class JsonRpcEngine extends SafeEventEmitter {
      */
     // This function is used in tests, so we cannot easily change it to use the
     // hash syntax.
-    // eslint-disable-next-line no-restricted-syntax
     async _promiseHandle(request) {
         return new Promise((resolve, reject) => {
             __classPrivateFieldGet(this, _JsonRpcEngine_instances, "m", _JsonRpcEngine_handle).call(this, request, (error, res) => {
                 // For notifications, the response will be `undefined`, and any caught
                 // errors are unexpected and should be surfaced to the caller.
                 if (error && res === undefined) {
+                    // We are not going to change this behavior.
+                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                     reject(error);
                 }
                 else {
@@ -363347,7 +363341,7 @@ async function _JsonRpcEngine_handle(callerReq, callback) {
                 if (returnHandler) {
                     if (typeof returnHandler !== 'function') {
                         end(new JsonRpcError(errorCodes.rpc.internal, `JsonRpcEngine: "next" return handlers must be functions. ` +
-                            `Received "${typeof returnHandler}" for request:\n${jsonify(request)}`, { request }));
+                            `Received "${typeof returnHandler}" for request:\n${stringify(request)}`, { request }));
                     }
                     returnHandlers.push(returnHandler);
                 }
@@ -363365,25 +363359,85 @@ async function _JsonRpcEngine_handle(callerReq, callback) {
 }, _JsonRpcEngine_runReturnHandlers = async function _JsonRpcEngine_runReturnHandlers(handlers) {
     for (const handler of handlers) {
         await new Promise((resolve, reject) => {
+            // We are not going to change this behavior.
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             handler((error) => (error ? reject(error) : resolve()));
         });
     }
 }, _JsonRpcEngine_checkForCompletion = function _JsonRpcEngine_checkForCompletion(request, response, isComplete) {
     if (!hasProperty(response, 'result') && !hasProperty(response, 'error')) {
-        throw new JsonRpcError(errorCodes.rpc.internal, `JsonRpcEngine: Response has no error or result for request:\n${jsonify(request)}`, { request });
+        throw new JsonRpcError(errorCodes.rpc.internal, `JsonRpcEngine: Response has no error or result for request:\n${stringify(request)}`, { request });
     }
     if (!isComplete) {
-        throw new JsonRpcError(errorCodes.rpc.internal, `JsonRpcEngine: Nothing ended request:\n${jsonify(request)}`, { request });
+        throw new JsonRpcError(errorCodes.rpc.internal, `JsonRpcEngine: Nothing ended request:\n${stringify(request)}`, { request });
     }
 };
+
 /**
- * JSON-stringifies a request object.
+ * JsonRpcEngine only accepts callback-based middleware directly.
+ * createAsyncMiddleware exists to enable consumers to pass in async middleware
+ * functions.
+ *
+ * Async middleware have no "end" function. Instead, they "end" if they return
+ * without calling "next". Rather than passing in explicit return handlers,
+ * async middleware can simply await "next", and perform operations on the
+ * response object when execution resumes.
  *
- * @param request - The request object to JSON-stringify.
- * @returns The JSON-stringified request object.
+ * To accomplish this, createAsyncMiddleware passes the async middleware a
+ * wrapped "next" function. That function calls the internal JsonRpcEngine
+ * "next" function with a return handler that resolves a promise when called.
+ *
+ * The return handler will always be called. Its resolution of the promise
+ * enables the control flow described above.
+ *
+ * @deprecated Use `JsonRpcEngineV2` and its corresponding types instead.
+ * @param asyncMiddleware - The asynchronous middleware function to wrap.
+ * @returns The wrapped asynchronous middleware function, ready to be consumed
+ * by JsonRpcEngine.
  */
-function jsonify(request) {
-    return JSON.stringify(request, null, 2);
+function createAsyncMiddleware(asyncMiddleware) {
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    return async (request, response, next, end) => {
+        // nextPromise is the key to the implementation
+        // it is resolved by the return handler passed to the
+        // "next" function
+        let resolveNextPromise;
+        const nextPromise = new Promise((resolve) => {
+            resolveNextPromise = resolve;
+        });
+        let returnHandlerCallback = null;
+        let nextWasCalled = false;
+        // This will be called by the consumer's async middleware.
+        const asyncNext = async () => {
+            nextWasCalled = true;
+            // We pass a return handler to next(). When it is called by the engine,
+            // the consumer's async middleware will resume executing.
+            next((runReturnHandlersCallback) => {
+                // This callback comes from JsonRpcEngine._runReturnHandlers
+                returnHandlerCallback = runReturnHandlersCallback;
+                resolveNextPromise();
+            });
+            return nextPromise;
+        };
+        try {
+            await asyncMiddleware(request, response, asyncNext);
+            if (nextWasCalled) {
+                await nextPromise; // we must wait until the return handler is called
+                returnHandlerCallback(null);
+            }
+            else {
+                end(null);
+            }
+        }
+        catch (error) {
+            if (returnHandlerCallback) {
+                returnHandlerCallback(error);
+            }
+            else {
+                end(error);
+            }
+        }
+    };
 }
 
 const byteToHex = [];
@@ -363448,6 +363502,14 @@ var __name$5 = (target, value) => __defProp$5(target, "name", { value, configura
 // src/engine/requestSchemas.ts
 var requestSchemas = {};
 
+// src/engine/rpcMethodHandlersFromAccountBalanceViewer.ts
+var rpcMethodHandlersFromAccountBalanceViewer = /* @__PURE__ */ __name$5((viewer) => {
+  return {
+    accountBalanceViewer_accountsBalances: /* @__PURE__ */ __name$5((params) => viewer.accountsBalances(params[0], params[1]), "accountBalanceViewer_accountsBalances"),
+    accountBalanceViewer_accountsBalancesHistory: /* @__PURE__ */ __name$5((params) => viewer.accountsBalancesHistory(params[0], params[1]), "accountBalanceViewer_accountsBalancesHistory")
+  };
+}, "rpcMethodHandlersFromAccountBalanceViewer");
+
 // src/engine/rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts
 var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = /* @__PURE__ */ __name$5((viewer) => {
   return {
@@ -363532,6 +363594,13 @@ var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name$5((connection, netw
       ...rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position)
     };
   }
+  const accountBalanceViewer = viewer?.account?.balance;
+  if (accountBalanceViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromAccountBalanceViewer(accountBalanceViewer)
+    };
+  }
   return result;
 }, "rpcMethodHandlersFromConnection");
 
@@ -363561,6 +363630,72 @@ var JsonRpcErrorCodes = {
 
 // src/types/JsonRpc.ts
 var jsonrpc = "2.0";
+var AccountBalanceViewerRpcSchemas = {
+  accountBalanceViewer_accountsBalances: {
+    params: {
+      to: union$1([
+        tuple([
+          array$1(AddressZod)
+        ]),
+        tuple([
+          array$1(AddressZod),
+          union$1([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ]),
+      from: union$1([
+        tuple([
+          array$1(AddressZod)
+        ]),
+        tuple([
+          array$1(AddressZod),
+          union$1([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: record$1(AddressZod, BigIntToJsonZod),
+      from: record$1(AddressZod, JsonToBigIntZod)
+    }
+  },
+  accountBalanceViewer_accountsBalancesHistory: {
+    params: {
+      to: union$1([
+        tuple([
+          array$1(AddressZod)
+        ]),
+        tuple([
+          array$1(AddressZod),
+          union$1([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ]),
+      from: union$1([
+        tuple([
+          array$1(AddressZod)
+        ]),
+        tuple([
+          array$1(AddressZod),
+          union$1([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: record$1(AddressZod, array$1(AccountBalanceHistoryItemZod)),
+      from: record$1(AddressZod, array$1(AccountBalanceHistoryItemZod))
+    }
+  }
+};
 var NetworkStakeViewerRpcSchemas = {
   networkStakeViewer_active: {
     params: {
@@ -363660,10 +363795,8 @@ var XyoSignerRpcSchemas = {
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod,
-      from: SignedHydratedTransactionZod.transform((data) => asHydratedTransactionWithStorageMeta(data, {
-        required: true
-      }))
+      to: SignedHydratedTransactionWithHashMetaZod,
+      from: SignedHydratedTransactionWithHashMetaZod
     }
   }
 };
@@ -364388,6 +364521,7 @@ var XyoViewerRpcSchemas = {
 
 // src/types/schema/AllRpcSchemas.ts
 var AllRpcSchemas = {
+  ...AccountBalanceViewerRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
   ...XyoViewerRpcSchemas,
@@ -364467,6 +364601,22 @@ var createResponseSchema = /* @__PURE__ */ __name$5((resultSchema = _undefined()
     }
   }
 });
+({
+  mempoolViewer_pendingTransactions: {
+    params: {
+      to: tuple([
+        PendingTransactionsOptionsZod.optional()
+      ]),
+      from: tuple([
+        PendingTransactionsOptionsZod.optional()
+      ])
+    },
+    result: {
+      to: array$1(SignedHydratedTransactionWithHashMetaZod),
+      from: array$1(SignedHydratedTransactionWithHashMetaZod)
+    }
+  }
+});
 ({
   networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
@@ -364854,11 +365004,13 @@ var HttpRpcTransport = class {
   static {
     __name$5(this, "HttpRpcTransport");
   }
+  _passThrough;
   _rpcUrl;
   _schemas;
-  constructor(rpcUrl, schemas) {
+  constructor(rpcUrl, schemas, passThrough = false) {
     this._rpcUrl = rpcUrl;
     this._schemas = schemas;
+    this._passThrough = passThrough;
   }
   async sendRequest(method, params) {
     return await this.callRpc(this._rpcUrl, this._schemas, method, params);
@@ -364871,15 +365023,19 @@ var HttpRpcTransport = class {
         id,
         method
       };
+      const schema = schemas[method];
       if (params) {
-        body.params = schemas[method].params.to.parse(params);
+        body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? json$3().parse(params) : void 0;
+        if (!isDefined(body.params)) {
+          throw new Error(`RPC method ${String(method)} missing schema`);
+        }
       }
       const res = await new Axios(axiosJsonConfig()).post(url, body);
-      const json = res.data;
-      if (isUndefinedOrNull(json) || json.error) {
-        throw new Error(json.error.message);
+      const json2 = res.data;
+      if (isUndefinedOrNull(json2) || json2.error) {
+        throw new Error(json2.error.message);
       }
-      return schemas[method].result.from.parse(json.result);
+      return schemas[method].result.from.parse(json2.result);
     } catch (ex) {
       let message = isError$1(ex) ? ex.message : String(ex);
       if (isAxiosError(ex)) {
@@ -364977,6 +365133,53 @@ var NodeXyoRunner = class {
   }, "getPendingArchivist");
 };
 
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
+var JsonRpcAccountBalanceViewerMethods = class {
+  static {
+    __name$5(this, "JsonRpcAccountBalanceViewerMethods");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async accountsBalances(address, headOrRange) {
+    return await this.transport.sendRequest("accountBalanceViewer_accountsBalances", headOrRange ? [
+      address,
+      headOrRange
+    ] : [
+      address
+    ]);
+  }
+  async accountsBalancesHistory(address, headOrRange) {
+    return await this.transport.sendRequest("accountBalanceViewer_accountsBalancesHistory", headOrRange ? [
+      address,
+      headOrRange
+    ] : [
+      address
+    ]);
+  }
+};
+
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
+(class extends JsonRpcAccountBalanceViewerMethods {
+  static {
+    __name$5(this, "JsonRpcAccountBalanceViewer");
+  }
+  constructor(transport) {
+    super(transport);
+  }
+  async accountBalance(address, headOrRange) {
+    return (await this.accountsBalances([
+      address
+    ], headOrRange))[address] ?? asAttoXL1(0);
+  }
+  async accountBalanceHistory(address, headOrRange) {
+    return (await this.accountsBalancesHistory([
+      address
+    ], headOrRange))[address] ?? [];
+  }
+});
+
 // src/provider/viewer/JsonRpcViewer.ts
 var JsonRpcViewer = class {
   static {
@@ -365140,12 +365343,12 @@ var JsonRpcXyoViewer = class {
     throw new Error("Method not implemented.");
   }
   async blockByHash(hash) {
-    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_blockByHash", [
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_blockByHash", [
       hash
     ])) ?? null;
   }
   async blockByNumber(blockNumber) {
-    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_blockByNumber", [
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_blockByNumber", [
       blockNumber
     ])) ?? null;
   }
@@ -365153,9 +365356,7 @@ var JsonRpcXyoViewer = class {
     return (await this.transport.sendRequest("xyoViewer_blocksByHash", [
       hash,
       limit
-    ])).map((b) => asHydratedBlock(b, {
-      required: true
-    }));
+    ])).map((b) => asSignedHydratedBlockWithHashMeta(b, true));
   }
   async chainId() {
     return await this.transport.sendRequest("xyoViewer_chainId");
@@ -365166,9 +365367,7 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async currentBlock() {
-    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_currentBlock"), {
-      required: true
-    });
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_currentBlock"), true);
   }
   async currentBlockHash() {
     return await this.transport.sendRequest("xyoViewer_currentBlockHash");
@@ -365451,10 +365650,9 @@ var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
     return await this.transport.sendRequest("xyoSigner_address");
   }
   async signTransaction(tx) {
-    const ret = await this.transport.sendRequest("xyoSigner_signTransaction", [
+    return await this.transport.sendRequest("xyoSigner_signTransaction", [
       tx
     ]);
-    return ret;
   }
 });
 
@@ -365675,7 +365873,7 @@ var addDataLakeRoutes$2 = /* @__PURE__ */ __name$4((app) => {
     archivistModuleIdentifier
   }));
 }, "addDataLakeRoutes");
-var addRpcRoutes = /* @__PURE__ */ __name$4(async (app, transferSummaryMap, stakedChainContext, initRewardsCache) => {
+var addRpcRoutes = /* @__PURE__ */ __name$4(async (app, transferSummaryMap, stakedChainContext, accountBalanceViewer, initRewardsCache) => {
   const { node } = app;
   const runner = new NodeXyoRunner(node);
   const networkStakeViewer = await SimpleNetworkStakeViewer.create({
@@ -365688,6 +365886,7 @@ var addRpcRoutes = /* @__PURE__ */ __name$4(async (app, transferSummaryMap, stak
     node,
     rewardMultipliers: RewardMultipliers,
     initRewardsCache,
+    accountBalanceViewer,
     context: stakedChainContext,
     transfersSummaryContext: {
       ...stakedChainContext,
@@ -365719,14 +365918,14 @@ var addRpcRoutes = /* @__PURE__ */ __name$4(async (app, transferSummaryMap, stak
 }, "addRpcRoutes");
 
 // src/server/routes/addRoutes.ts
-var addRoutes$3 = /* @__PURE__ */ __name$4(async (app, transferSummaryMap, stakedChainContext, initRewardsCache) => {
-  await addRpcRoutes(app, transferSummaryMap, stakedChainContext, initRewardsCache);
+var addRoutes$3 = /* @__PURE__ */ __name$4(async (app, transferSummaryMap, stakedChainContext, accountBalanceViewer, initRewardsCache) => {
+  await addRpcRoutes(app, transferSummaryMap, stakedChainContext, accountBalanceViewer, initRewardsCache);
   addDataLakeRoutes$2(app);
   addNodeRoutes$1(app);
 }, "addRoutes");
 
 // src/server/app.ts
-var getApp$3 = /* @__PURE__ */ __name$4(async (node, transferSummaryMap, stakedChainContext, initRewardsCache) => {
+var getApp$3 = /* @__PURE__ */ __name$4(async (node, transferSummaryMap, stakedChainContext, accountBalanceViewer, initRewardsCache) => {
   addInstrumentation$3();
   const app = express2();
   app.set("etag", false);
@@ -365741,7 +365940,7 @@ var getApp$3 = /* @__PURE__ */ __name$4(async (node, transferSummaryMap, stakedC
   app.use(customPoweredByHeader);
   disableCaseSensitiveRouting(app);
   app.node = node;
-  await addRoutes$3(app, transferSummaryMap, stakedChainContext, initRewardsCache);
+  await addRoutes$3(app, transferSummaryMap, stakedChainContext, accountBalanceViewer, initRewardsCache);
   app.use(standardErrors);
   return app;
 }, "getApp");
@@ -365814,7 +366013,32 @@ async function getServer$3(context) {
   await Promise.all(mods.map((mod) => {
     return mod.start?.() ?? (() => true);
   }));
-  const app = await getApp$3(node, transferSummaryMap, stakedChainContext, config.api.initRewardsCache);
+  const chainIterator = await initChainIterator({
+    config,
+    logger,
+    chainMap,
+    head: assertEx(await findMostRecentBlock(chainArchivist), () => "No head found in chainArchivist")
+  });
+  const blockViewer = blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist);
+  const accountBalanceViewer = await SimpleAccountBalanceViewer.create({
+    context: {
+      chainId: stakedChainContext.chainId,
+      store: stakedChainContext.store,
+      head: stakedChainContext.head,
+      stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+      summaryMap: balanceSummaryMap
+    },
+    transferContext: {
+      chainId: stakedChainContext.chainId,
+      store: stakedChainContext.store,
+      head: stakedChainContext.head,
+      stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+      summaryMap: transferSummaryMap
+    },
+    blockViewer
+  });
+  assertEx(await accountBalanceViewer.start(), () => "Failed to start SimpleAccountBalanceViewer");
+  const app = await getApp$3(node, transferSummaryMap, stakedChainContext, accountBalanceViewer, config.api.initRewardsCache);
   const server = app.listen(port, hostname$3, () => logger?.log(`[API] Server listening at http://${hostname$3}:${port}`));
   server.setTimeout(2e4);
   return server;
@@ -366324,15 +366548,16 @@ var getApp$1 = /* @__PURE__ */ __name$2((node) => {
 var getLocator$1 = /* @__PURE__ */ __name$2(async (context) => {
   const { config, logger } = context;
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9466 } = config.telemetry?.metrics?.scrape ?? {};
   const { traceProvider, meterProvider } = await initTelemetry({
     attributes: {
-      serviceName: "xl1-api",
+      serviceName: "xl1-mempool",
       serviceVersion: "1.0.0"
     },
     otlpEndpoint,
     metricsConfig: {
-      endpoint: "/metrics",
-      port: 9465
+      endpoint,
+      port
     }
   });
   if (isDefined(logger)) AbstractModule.defaultLogger = logger;
@@ -367010,7 +367235,7 @@ var ChainStepRewardsClaimSentinel = class extends AbstractSentinel {
       transferPayload
     ], [], {
       nbf: currentBlockNumber,
-      exp: currentBlockNumber + 10
+      exp: asXL1BlockNumber(currentBlockNumber + 10)
     });
     if (isDefined(result)) return result[1];
   }
@@ -367022,8 +367247,8 @@ var ConfirmedClaimValuesZod = z.object({
   "To XL1 Address": AddressZod,
   "XL1 Amount": z.string(),
   "XL1 Amount (Hex)": HexZod,
-  "XL1 Not after block": z.number().int().nonnegative(),
-  "XL1 Not before block": z.number().int().nonnegative()
+  "XL1 Not after block": XL1BlockNumberZod,
+  "XL1 Not before block": XL1BlockNumberZod
 });
 var parseConfirmedClaimValues = /* @__PURE__ */ __name$1((values) => {
   return {
@@ -367121,15 +367346,16 @@ var DerivedAddressWalletTransferSentinel = class extends AbstractSentinel {
 var getLocator = /* @__PURE__ */ __name$1(async (context) => {
   const { config, logger } = context;
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9467 } = config.telemetry?.metrics?.scrape ?? {};
   const { traceProvider, meterProvider } = await initTelemetry({
     attributes: {
-      serviceName: "xl1-rewards",
+      serviceName: "xl1-reward-redemption",
       serviceVersion: "1.0.0"
     },
     otlpEndpoint,
     metricsConfig: {
-      endpoint: "/metrics",
-      port: 9465
+      endpoint,
+      port
     }
   });
   if (isDefined(logger)) AbstractModule.defaultLogger = logger;
@@ -374449,7 +374675,7 @@ var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
     );
   }
   async checkInsertedForNewHead(data) {
-    const candidateBlock = sortBlocks(filterAs(data.payloads, asBlockBoundWitness)).at(-1);
+    const candidateBlock = sortBlocks(data.payloads.filter(isBlockBoundWitness)).at(-1);
     await this.updateHeadIfNewer(candidateBlock);
   }
   async pollForNewHead() {
@@ -374482,9 +374708,29 @@ var ProducerActor = class _ProducerActor extends Actor {
   }
   _lastProducedBlock;
   _lastRedeclarationIntent;
+  _metricAttributes;
+  _producerActorBlockProductionAttempts;
+  _producerActorBlockProductionChecks;
+  _producerActorBlocksProduced;
+  _producerActorBlocksPublished;
   _produceBlockMutex = new Mutex$1();
   constructor(params) {
     super(params.producer.address, "Producer", params);
+    this._metricAttributes = {
+      address: this.account.address.toString()
+    };
+    this._producerActorBlockProductionChecks = this.meter?.createCounter("producer_actor_block_production_checks", {
+      description: "Number of block production checks"
+    });
+    this._producerActorBlockProductionAttempts = this.meter?.createCounter("producer_actor_block_production_attempts", {
+      description: "Number of block production attempts"
+    });
+    this._producerActorBlocksProduced = this.meter?.createCounter("producer_actor_blocks_produced", {
+      description: "Number of blocks produced"
+    });
+    this._producerActorBlocksPublished = this.meter?.createCounter("producer_actor_blocks_published", {
+      description: "Number of blocks published"
+    });
   }
   get account() {
     return assertEx(this.params.account, () => "account not set");
@@ -374541,6 +374787,7 @@ var ProducerActor = class _ProducerActor extends Actor {
     return timeToProducerExpiration;
   }
   async produceBlock() {
+    this._producerActorBlockProductionChecks?.add(1, this._metricAttributes);
     await this.spanAsync("produceBlock", async () => {
       if (this._produceBlockMutex.isLocked()) {
         this.logger?.log("Skipping block production, previous production still in progress");
@@ -374550,24 +374797,23 @@ var ProducerActor = class _ProducerActor extends Actor {
         const headStart = Date.now();
         const head = await this.chainIterator.head();
         const headDuration = Date.now() - headStart;
-        if (headDuration > 500) {
-          this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex(head._hash)}`);
-        }
+        if (headDuration > 500) this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex(head._hash)}`);
         const headHash = head._hash;
         if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
           this.logger?.log("Block already produced:", `0x${toHex(this._lastProducedBlock[0].block)}`, this._lastProducedBlock[0].block);
         } else {
+          this._producerActorBlockProductionAttempts?.add(1, this._metricAttributes);
           const nextStart = Date.now();
           const nextBlock = await this.producer.next(head);
           const nextDuration = Date.now() - nextStart;
-          if (nextDuration > 1e3) {
-            this.logger?.warn(`[Slow] Generated next block in ${nextDuration}ms, block: ${nextBlock?.[0]._hash}`);
-          }
+          if (nextDuration > 1e3) this.logger?.warn(`[Slow] Generated next block in ${nextDuration}ms, block: ${nextBlock?.[0]._hash}`);
           if (nextBlock) {
             const displayBlockNumber = `0x${toHex(nextBlock[0].block)}`;
             this.logger?.log("Produced block:", displayBlockNumber);
+            this._producerActorBlocksProduced?.add(1, this._metricAttributes);
             await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock));
             this.logger?.log("Published block:", displayBlockNumber, nextBlock[0].block);
+            this._producerActorBlocksPublished?.add(1, this._metricAttributes);
             this._lastProducedBlock = nextBlock;
           }
         }
@@ -374607,7 +374853,7 @@ var ProducerActor = class _ProducerActor extends Actor {
     this.logger?.log("Submitting redeclaration intent for producer:", this.account.address);
     const tx = await buildTransaction(this.chainIterator.chainId, [
       redeclarationIntent
-    ], [], this.account, currentBlock, currentBlock + 1e3);
+    ], [], this.account, currentBlock, asXL1BlockNumber(currentBlock + 1e3, true));
     const payloads = flattenHydratedTransaction(tx);
     const root = tx[0]._hash;
     const payloadBundle = new PayloadBuilder({
@@ -375040,13 +375286,15 @@ async function initTransferSummaryMap(params) {
 }
 __name(initTransferSummaryMap, "initTransferSummaryMap");
 var balanceServiceSingleton;
-var initBalanceService = /* @__PURE__ */ __name(async (params) => {
+var initAccountBalanceService = /* @__PURE__ */ __name(async (params) => {
+  const { config: config2, logger } = params;
   if (balanceServiceSingleton) return balanceServiceSingleton;
-  return await timeBudget("initBalanceService", params.logger, async () => {
-    balanceServiceSingleton = await BaseAccountBalanceService.create(params);
+  return await timeBudget("initAccountBalanceService", params.logger, async () => {
+    config2.services?.accountBalanceViewerEndpoint ?? config2.services?.apiEndpoint;
+    balanceServiceSingleton = await BaseAccountBalanceService.create(params.params);
     return balanceServiceSingleton;
   }, 2e3, true);
-}, "initBalanceService");
+}, "initAccountBalanceService");
 var canUseChainId = /* @__PURE__ */ __name((config2) => {
   return isDefined(config2.evm.chainId);
 }, "canUseChainId");
@@ -375280,7 +375528,7 @@ var getBridgeSourceObservation = /* @__PURE__ */ __name(async (previousBlock, ac
   ]);
 }, "getBridgeSourceObservation");
 var getFirstBlockForNewChain = /* @__PURE__ */ __name(async (forkBlock, account, chainService) => {
-  const { _hash: previousBlockHash, block: previousBlockNumber, step_hashes: previousStepHashes, protocol } = forkBlock;
+  const { _hash: previousBlockHash, block: previousBlockNumber, step_hashes: previousStepHashes = [], protocol } = forkBlock;
   const chainId = chainService.chainId;
   const options = {
     blockPayloads: [],
@@ -375323,7 +375571,7 @@ var getForkFromBlock = /* @__PURE__ */ __name(async (head, chainService, chainAr
       ]);
       const forkedChainId = await chainService.forkedChainId();
       const forkedAtBlockNumber = Number(await chainService.forkedAtBlockNumber());
-      if (isBlockBoundWitnessWithHashMeta(forkedAtBlock) && forkedAtBlock.chain === forkedChainId && forkedAtBlock.block === forkedAtBlockNumber) {
+      if (isSignedBlockBoundWitnessWithHashMeta(forkedAtBlock) && forkedAtBlock.chain === forkedChainId && forkedAtBlock.block === forkedAtBlockNumber) {
         return forkedAtBlock;
       }
     }
@@ -375366,30 +375614,6 @@ var initHead = /* @__PURE__ */ __name(async (params) => {
   headSingleton = head;
   return headSingleton;
 }, "initHead");
-var chainIteratorServiceSingleton;
-var stakeIntentServiceSingleton;
-var electionServiceSingleton;
-var initChainIterator = /* @__PURE__ */ __name((params) => {
-  if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton;
-  return timeBudget("initChainIterator", params.logger, () => {
-    chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
-    return chainIteratorServiceSingleton;
-  }, 2e3, true);
-}, "initChainIterator");
-var initStakeIntentService = /* @__PURE__ */ __name((params) => {
-  if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
-  return timeBudget("initStakeIntentService", params.logger, () => {
-    stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
-    return stakeIntentServiceSingleton;
-  }, 2e3, true);
-}, "initStakeIntentService");
-var initElectionService = /* @__PURE__ */ __name((params) => {
-  if (electionServiceSingleton) return electionServiceSingleton;
-  return timeBudget("initElectionService", params.logger, () => {
-    electionServiceSingleton = BaseElectionService.create(params);
-    return electionServiceSingleton;
-  }, 2e3, true);
-}, "initElectionService");
 var serviceSingleton;
 var initPendingTransactions = /* @__PURE__ */ __name(async (params) => {
   if (serviceSingleton) return serviceSingleton;
@@ -375585,6 +375809,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     statusReporter
   }));
   const { otlpEndpoint } = config2.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9464 } = config2.telemetry?.metrics?.scrape ?? {};
   const telemetryConfig = {
     attributes: {
       serviceName: "xl1-producer",
@@ -375592,8 +375817,8 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     },
     otlpEndpoint,
     metricsConfig: {
-      endpoint: "/metrics",
-      port: 9464
+      endpoint,
+      port
     }
   };
   const [{ traceProvider, meterProvider }, account] = await Promise.all([
@@ -375602,6 +375827,11 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
   ]);
   const allowedRewardRedeemers = config2.validation?.allowedRewardRedeemers ?? [];
   const allowedRewardEscrowAccountSigners = config2.validation?.allowedRewardEscrowAccountSigners ?? [];
+  const baseParamsFields = {
+    logger,
+    meterProvider,
+    traceProvider
+  };
   const initParams = {
     config: config2,
     logger,
@@ -375665,6 +375895,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
       ...initParams
     }))
   ]);
+  const blockViewer = blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist);
   const balanceContext = {
     stepSemaphores: StepSizes.map(() => new Semaphore(20)),
     store: {
@@ -375696,12 +375927,16 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     summaryMap: transferSummaryMap
   };
   const [balanceService] = await Promise.all([
-    startupSpanAsync("BalanceService", () => initBalanceService({
-      name: "BalanceService",
-      context: balanceContext,
-      chainArchivist,
-      chainIterator,
-      transferContext,
+    startupSpanAsync("BalanceService", () => initAccountBalanceService({
+      params: {
+        name: "BalanceService",
+        config: {},
+        context: balanceContext,
+        blockViewer,
+        chainArchivist,
+        chainIterator,
+        transferContext
+      },
       ...initParams
     })),
     startupSpanAsync("TransferService", () => initTransferService({
@@ -375759,7 +375994,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     ...initParams
   };
   const producer = await startupSpanAsync("Producer", () => initBlockProducer(producerParams));
-  const result = {
+  const services = {
     account,
     balance: balanceService,
     chainArchivist,
@@ -375778,11 +376013,14 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
   logger?.log("All services created. Starting...");
   const startableServices = [
     balanceSummaryMap,
-    ...Object.values(result)
+    ...Object.values(services)
   ].filter(isStartable);
   assertEx((await Promise.all(startableServices.map((service) => service.start()))).every(Boolean), () => "One or more services failed to start");
   logger?.log("All services started successfully.");
-  return result;
+  return {
+    ...services,
+    ...baseParamsFields
+  };
 }, "initServices");
 function runApi(context) {
   void getServer$3(context);
@@ -375915,7 +376153,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined("1.16.22") ? "1.16.22" : "unknown";
+var version = isDefined("1.16.24") ? "1.16.24" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name((configuration2) => {
   const logger = initLogger(configuration2);
   const orchestrator = new Orchestrator(logger);