@xyo-network/xl1-protocol-sdk 1.16.23 → 1.16.25

package/dist/neutral/viewers/AccountBalance.d.ts

@@ -3,46 +3,40 @@ import { type AttoXL1, type XL1BlockRange } from '@xyo-network/xl1-protocol';
 import z from 'zod';
 export declare const AccountBalanceHistoryItemZod: z.ZodTuple<[z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>>;
-    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
-        __schema: true;
-    }, string>>]>>;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>>;
-    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodString>;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodNull]>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-    previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>;
-    protocol: z.ZodNumber;
-    step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+    protocol: z.ZodOptional<z.ZodNumber>;
+    step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
     $epoch: z.ZodNumber;
     _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
 }, z.z.core.$strip>, z.ZodNullable<z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>>;
-    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>;
-    payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
-        __schema: true;
-    }, string>>]>>;
-    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>>;
-    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodString>;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodNull]>>;
-    _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
-    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
-    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
     fees: z.ZodObject<{
         base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
         gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
         gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
         priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
     }, z.z.core.$strip>;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
     script: z.ZodOptional<z.ZodArray<z.ZodString>>;
     _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>;
@@ -58,11 +52,11 @@ export declare const AccountBalanceHistoryItemZod: z.ZodTuple<[z.ZodObject<{
 }, z.z.core.$strip>], null>;
 export type AccountBalanceHistoryItem = z.infer<typeof AccountBalanceHistoryItemZod>;
 export interface AccountBalanceViewerMethods {
-    accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AttoXL1>;
-    accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AccountBalanceHistoryItem[]>;
     accountsBalances(address: Address[], headOrRange?: Hash | XL1BlockRange): Promisable<Partial<Record<Address, AttoXL1>>>;
     accountsBalancesHistory(address: Address[], headOrRange?: Hash | XL1BlockRange): Promisable<Partial<Record<Address, AccountBalanceHistoryItem[]>>>;
 }
 export interface AccountBalanceViewer extends AccountBalanceViewerMethods {
+    accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AttoXL1>;
+    accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AccountBalanceHistoryItem[]>;
 }
 //# sourceMappingURL=AccountBalance.d.ts.map

package/dist/neutral/viewers/AccountBalance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccountBalance.d.ts","sourceRoot":"","sources":["../../../src/viewers/AccountBalance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAAE,IAAI,EAAE,UAAU,EAC1B,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,aAAa,EACnB,MAAM,2BAA2B,CAAA;AAClC,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIvC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,MAAM,WAAW,2BAA2B;IAC1C,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IACzF,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,yBAAyB,EAAE,CAAC,CAAA;IAEpH,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IACvH,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,yBAAyB,EAAE,CAAC,CAAC,CAAC,CAAA;CACnJ;AAED,MAAM,WAAW,oBAAqB,SAAQ,2BAA2B;CAAG"}
+{"version":3,"file":"AccountBalance.d.ts","sourceRoot":"","sources":["../../../src/viewers/AccountBalance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAAE,IAAI,EAAE,UAAU,EAC1B,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,aAAa,EACnB,MAAM,2BAA2B,CAAA;AAElC,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIvC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IACvH,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,yBAAyB,EAAE,CAAC,CAAC,CAAC,CAAA;CACnJ;AAED,MAAM,WAAW,oBAAqB,SAAQ,2BAA2B;IACvE,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IACzF,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,yBAAyB,EAAE,CAAC,CAAA;CACrH"}

package/dist/neutral/viewers/Block.d.ts

@@ -1,10 +1,10 @@
 import type { Hash, Promisable } from '@xylabs/sdk-js';
-import type { HydratedBlock, XL1BlockNumber } from '@xyo-network/xl1-protocol';
+import type { SignedHydratedBlockWithHashMeta, XL1BlockNumber } from '@xyo-network/xl1-protocol';
 export interface BlockViewierMethods {
-    blockByHash(hash: Hash): Promisable<HydratedBlock | null>;
-    blockByNumber(block: XL1BlockNumber): Promisable<HydratedBlock | null>;
-    blocksByHash(hash: Hash, limit?: number): Promisable<HydratedBlock[]>;
-    currentBlock(): Promisable<HydratedBlock>;
+    blockByHash(hash: Hash): Promisable<SignedHydratedBlockWithHashMeta | null>;
+    blockByNumber(block: XL1BlockNumber): Promisable<SignedHydratedBlockWithHashMeta | null>;
+    blocksByHash(hash: Hash, limit?: number): Promisable<SignedHydratedBlockWithHashMeta[]>;
+    currentBlock(): Promisable<SignedHydratedBlockWithHashMeta>;
     currentBlockHash(): Promisable<Hash>;
     currentBlockNumber(): Promisable<XL1BlockNumber>;
 }

package/dist/neutral/viewers/Block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Block.d.ts","sourceRoot":"","sources":["../../../src/viewers/Block.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE9E,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IACzD,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IACtE,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,aAAa,EAAE,CAAC,CAAA;IAErE,YAAY,IAAI,UAAU,CAAC,aAAa,CAAC,CAAA;IACzC,gBAAgB,IAAI,UAAU,CAAC,IAAI,CAAC,CAAA;IACpC,kBAAkB,IAAI,UAAU,CAAC,cAAc,CAAC,CAAA;CACjD;AAED,MAAM,WAAW,WAAY,SAAQ,mBAAmB;CAAG"}
+{"version":3,"file":"Block.d.ts","sourceRoot":"","sources":["../../../src/viewers/Block.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,KAAK,EAAE,+BAA+B,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAEhG,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAAC,+BAA+B,GAAG,IAAI,CAAC,CAAA;IAC3E,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CAAC,+BAA+B,GAAG,IAAI,CAAC,CAAA;IACxF,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,+BAA+B,EAAE,CAAC,CAAA;IAEvF,YAAY,IAAI,UAAU,CAAC,+BAA+B,CAAC,CAAA;IAC3D,gBAAgB,IAAI,UAAU,CAAC,IAAI,CAAC,CAAA;IACpC,kBAAkB,IAAI,UAAU,CAAC,cAAc,CAAC,CAAA;CACjD;AAED,MAAM,WAAW,WAAY,SAAQ,mBAAmB;CAAG"}

package/dist/neutral/viewers/Mempool.d.ts

@@ -0,0 +1,14 @@
+import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol';
+import z from 'zod';
+export declare const PendingTransactionsOptionsZod: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    window: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>], null>>;
+}, z.z.core.$strip>;
+export type PendingTransactionsOptions = z.infer<typeof PendingTransactionsOptionsZod>;
+export interface MempoolViewerMethods {
+    pendingTransactions(options?: PendingTransactionsOptions): Promise<SignedHydratedTransactionWithHashMeta[]>;
+}
+export interface MempoolViewer extends MempoolViewerMethods {
+}
+//# sourceMappingURL=Mempool.d.ts.map

package/dist/neutral/viewers/Mempool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mempool.d.ts","sourceRoot":"","sources":["../../../src/viewers/Mempool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,2BAA2B,CAAA;AAEtF,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,6BAA6B;;;;mBAIxC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEtF,MAAM,WAAW,oBAAoB;IACnC,mBAAmB,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,OAAO,CAAC,qCAAqC,EAAE,CAAC,CAAA;CAC5G;AAED,MAAM,WAAW,aAAc,SAAQ,oBAAoB;CAAG"}

package/dist/neutral/viewers/index.d.ts

@@ -3,6 +3,7 @@ export * from './Block.ts';
 export * from './Chain.ts';
 export * from './ChainContract.ts';
 export * from './Fork.ts';
+export * from './Mempool.ts';
 export * from './NetworkStakeStepReward.ts';
 export * from './Stake.ts';
 export * from './StakeEvents.ts';

package/dist/neutral/viewers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/viewers/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,WAAW,CAAA;AACzB,cAAc,6BAA6B,CAAA;AAC3C,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/viewers/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol-sdk",
-  "version": "1.16.23",
+  "version": "1.16.25",
   "description": "XYO Layer One SDK Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -39,19 +39,19 @@
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/sdk-js": "~5.0.39",
-    "@xylabs/telemetry": "~5.0.39",
-    "@xyo-network/account": "~5.1.24",
-    "@xyo-network/account-model": "~5.1.24",
-    "@xyo-network/archivist-memory": "~5.1.24",
-    "@xyo-network/archivist-model": "~5.1.24",
-    "@xyo-network/boundwitness-builder": "~5.1.24",
-    "@xyo-network/boundwitness-model": "~5.1.24",
-    "@xyo-network/payload-builder": "~5.1.24",
-    "@xyo-network/payload-model": "~5.1.24",
-    "@xyo-network/wallet": "~5.1.24",
-    "@xyo-network/wallet-model": "~5.1.24",
-    "@xyo-network/xl1-protocol": "~1.13.13",
+    "@xylabs/sdk-js": "~5.0.42",
+    "@xylabs/telemetry": "~5.0.42",
+    "@xyo-network/account": "~5.2.10",
+    "@xyo-network/account-model": "~5.2.10",
+    "@xyo-network/archivist-memory": "~5.2.10",
+    "@xyo-network/archivist-model": "~5.2.10",
+    "@xyo-network/boundwitness-builder": "~5.2.10",
+    "@xyo-network/boundwitness-model": "~5.2.10",
+    "@xyo-network/payload-builder": "~5.2.10",
+    "@xyo-network/payload-model": "~5.2.10",
+    "@xyo-network/wallet": "~5.2.10",
+    "@xyo-network/wallet-model": "~5.2.10",
+    "@xyo-network/xl1-protocol": "~1.14.13",
     "async-mutex": "~0.5.0",
     "ethers": "~6.15.0",
     "lru-cache": "^11.2.2",
@@ -61,12 +61,12 @@
     "@types/node": "~24.10.1",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xyo-network/account": "~5.1.24",
-    "@xyo-network/boundwitness-validator": "~5.1.24",
+    "@xyo-network/account": "~5.2.10",
+    "@xyo-network/boundwitness-validator": "~5.2.10",
     "axios": "^1.13.2",
     "eslint": "^9.39.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.10"
+    "vitest": "~4.0.13"
   },
   "peerDependencies": {
     "axios": "^1.13.2"

package/src/block/hydrate/blockPayloadsFromHydratedBlock.ts

@@ -1,11 +1,11 @@
 import { assertEx } from '@xylabs/sdk-js'
-import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol'
-import { isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol'
+import { isTransactionBoundWitness } from '@xyo-network/xl1-protocol'
 
-export const blockPayloadsFromHydratedBlock = (block: HydratedBlock): WithStorageMeta<Payload>[] => {
+export const blockPayloadsFromHydratedBlock = (block: HydratedBlockWithStorageMeta): WithStorageMeta[] => {
   return block[0].payload_hashes.map(hash => assertEx(
     block[1].find(p => p._hash === hash),
     () => `missing payload ${hash}`,
-  )).filter(x => !isTransactionBoundWitnessWithStorageMeta(x))
+  )).filter(x => !isTransactionBoundWitness(x))
 }

package/src/block/hydrate/flattenHydratedBlock.ts

@@ -1,7 +1,7 @@
-import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol'
+import type { Payload } from '@xyo-network/payload-model'
+import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
 
-export const flattenHydratedBlock = (hydratedBlock: HydratedBlock): WithStorageMeta<Payload>[] => {
+export const flattenHydratedBlock = <B extends BlockBoundWitness, P extends Payload>(hydratedBlock: [B, P[]]): (P | B)[] => {
   const [blk, blkPayloads] = hydratedBlock
   return [...blkPayloads, blk]
 }

package/src/block/hydrate/flattenHydratedBlocks.ts

@@ -1,7 +1,7 @@
-import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
+import type { HydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
 
 import { flattenHydratedBlock } from './flattenHydratedBlock.ts'
 
-export const flattenHydratedBlocks = (hydratedBlocks: HydratedBlock[]): WithStorageMeta<Payload>[] =>
+export const flattenHydratedBlocks = (hydratedBlocks: HydratedBlockWithHashMeta[]): WithHashMeta<Payload>[] =>
   hydratedBlocks.flatMap(blk => flattenHydratedBlock(blk))

package/src/block/hydrate/hydrateBlock.ts

@@ -1,6 +1,6 @@
 import type { Hash } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol'
+import type { HydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
 import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
 
 import type { ChainStoreRead } from '../../model/index.ts'
@@ -11,7 +11,7 @@ export const hydrateBlock = async (
   hash: Hash,
   maxDepth: number = 1,
   minDepth = maxDepth,
-): Promise<HydratedBlock> => {
+): Promise<HydratedBlockWithHashMeta> => {
   assertEx(maxDepth >= 0, () => 'maxDepth must be greater than or equal to 0')
   assertEx(minDepth >= 0, () => 'minDepth must be greater than or equal to 0')
   assertEx(maxDepth >= minDepth, () => 'maxDepth must be greater than or equal to minDepth')

package/src/block/hydrate/transactionsFromHydratedBlock.ts

@@ -1,8 +1,6 @@
-import { filterAs } from '@xylabs/sdk-js'
-import type { WithStorageMeta } from '@xyo-network/payload-model'
-import type { HydratedBlock, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
-import { asTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import type { HydratedBlock, TransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import { isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
 
-export const transactionsFromHydratedBlock = (block: HydratedBlock): WithStorageMeta<TransactionBoundWitness>[] => {
-  return filterAs(block[1], asTransactionBoundWitnessWithStorageMeta)
+export const transactionsFromHydratedBlock = (block: HydratedBlock): TransactionBoundWitnessWithStorageMeta[] => {
+  return block[1].filter(isTransactionBoundWitnessWithStorageMeta)
 }

package/src/block/primitives/blockFromBlockNumber.ts

@@ -1,17 +1,28 @@
-import { asHash, type Hash } from '@xylabs/sdk-js'
+import {
+  asHash, type Hash, isDefined,
+} from '@xylabs/sdk-js'
 import { toSafeJsonString } from '@xylabs/sdk-js'
-import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { Signed } from '@xyo-network/boundwitness-model'
+import type { WithHashMeta } from '@xyo-network/payload-model'
 import type { BlockBoundWitness, XL1BlockNumber } from '@xyo-network/xl1-protocol'
-import { asBlockBoundWitnessWithStorageMeta, StepSizes } from '@xyo-network/xl1-protocol'
+import {
+  asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes,
+} from '@xyo-network/xl1-protocol'
 
 import { type ChainContextRead, withContextCacheResponse } from '../../model/index.ts'
 
-export async function blockFromBlockNumber(context: ChainContextRead, blockNumber: XL1BlockNumber): Promise<WithStorageMeta<BlockBoundWitness>> {
+export async function blockFromBlockNumber(context: ChainContextRead, blockNumber: XL1BlockNumber): Promise<WithHashMeta<Signed<BlockBoundWitness>>> {
   const cacheKey = `${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}.`)
     }
@@ -22,13 +33,22 @@ export async function blockFromBlockNumber(context: ChainContextRead, blockNumbe
         const possibleJumpBlockNumber = currentBlock.block - (currentBlock.block % stepSize) - 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(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 result = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock)
+          return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result.error}`
+        },
+      )
       if (currentBlock.block === blockNumber) {
         break
       }

package/src/config/Config.ts

@@ -1,7 +1,6 @@
 import * as z from 'zod'
 
 import { ApiConfigZod } from './Api.ts'
-import { AppConfigZod } from './App.ts'
 import { BridgeConfigZod } from './Bridge.ts'
 import { ChainConfigZod } from './Chain.ts'
 import { EvmConfigZod } from './Evm.ts'
@@ -9,6 +8,7 @@ import { LogConfigZod } from './Log.ts'
 import { MempoolConfigZod } from './Mempool.ts'
 import { ProducerConfigZod } from './Producer.ts'
 import { RewardRedemptionApiConfigZod } from './RewardRedemptionApi.ts'
+import { ServicesConfigZod } from './Services.ts'
 import { StorageConfigZod } from './storage/index.ts'
 import { TelemetryConfigZod } from './Telemetry.ts'
 import { ValidationConfigZod } from './Validation.ts'
@@ -18,13 +18,13 @@ export const Xl1CommonConfigSchema = z.object({ ...LogConfigZod.shape }).describ
 export const ConfigZod = z.object({
   ...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'),

package/src/config/Producer.ts

@@ -16,12 +16,6 @@ export const ProducerConfigZod = z.object({
     type: 'array',
   })),
 
-  apiEndpoint: z.string().optional().register(globalRegistry, {
-    description: 'Endpoint of the API to use for chain data',
-    title: 'producer.apiEndpoint',
-    type: 'string',
-  }),
-
   disableIntentRedeclaration: z.boolean().optional().register(globalRegistry, {
     description: 'Should the producer skip redeclaring their intent to continue producing blocks',
     title: 'producer.disableIntentRedeclaration',

package/src/config/Services.ts

@@ -0,0 +1,17 @@
+import { globalRegistry } from 'zod'
+import * as z from 'zod'
+
+export const ServicesConfigZod = z.object({
+  accountBalanceViewerEndpoint: z.string().optional().register(globalRegistry, {
+    description: 'Endpoint of the API to use for instantiating an external AccountBalanceViewer',
+    title: 'services.accountBalanceViewerEndpoint',
+    type: 'string',
+  }),
+  apiEndpoint: z.string().optional().register(globalRegistry, {
+    description: 'Endpoint of the API to use for instantiating an external Viewers',
+    title: 'services.apiEndpoint',
+    type: 'string',
+  }),
+})
+
+export type ServicesConfig = z.infer<typeof ServicesConfigZod>

package/src/config/Telemetry.ts

@@ -1,6 +1,23 @@
 import { globalRegistry } from 'zod'
 import * as z from 'zod'
 
+export const MetricsScrapeConfigZod = z.object({
+  path: z.string().default('/metrics').register(globalRegistry, {
+    default: '/metrics',
+    description: 'Path for the metrics scrape endpoint',
+    title: 'telemetry.metrics.scrape.path',
+    type: 'string',
+  }),
+  port: z.coerce.number().default(9464).register(globalRegistry, {
+    default: 9464,
+    description: 'Port for the metrics scrape endpoint',
+    title: 'telemetry.metrics.scrape.port',
+    type: 'number',
+  }),
+}).describe('Metrics scrape configuration')
+
+export const MetricsConfigZod = z.object({ scrape: MetricsScrapeConfigZod }).describe('Metrics configuration options')
+
 export const OpenTelemetryConfigZod = z.object({
   // OpenTelemetry options
   otlpEndpoint: z.url().optional().register(globalRegistry, {
@@ -11,6 +28,8 @@ export const OpenTelemetryConfigZod = z.object({
 })
 
 export const TelemetryConfigZod = z.object({
+  // Metrics configuration
+  metrics: MetricsConfigZod.optional().describe('Metrics configuration'),
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe('OpenTelemetry configuration'),
 }).describe('Telemetry configuration options')

package/src/index.ts

@@ -20,4 +20,4 @@ export * from './utils/index.ts'
 export * from './validation/index.ts'
 export * from './viewers/index.ts'
 export * from './wallet/index.ts'
-export * from './zod/index.ts'
+// export * from './zod/index.ts'

package/src/instances/transaction/HydratedTransaction.ts

@@ -1,10 +1,8 @@
-import type { AllowedBlockPayload, HydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
+import type { AllowedBlockPayload, HydratedTransaction } from '@xyo-network/xl1-protocol'
 
 import type { HydratedBoundWitnessInstance } from '../HydratedBoundWitness.ts'
-import type { SignedInstance } from '../modifiers/index.ts'
 import type { TransactionFieldsInstance } from './TransactionFields.ts'
 
-export interface HydratedTransactionInstance<T extends HydratedTransactionWithStorageMeta = HydratedTransactionWithStorageMeta,
-  TElevatedPayload extends AllowedBlockPayload = AllowedBlockPayload>
-  extends TransactionFieldsInstance<T[1][number] & TElevatedPayload>, HydratedBoundWitnessInstance<T>, SignedInstance {
+export interface HydratedTransactionInstance<T extends HydratedTransaction = HydratedTransaction>
+  extends TransactionFieldsInstance<T[1][number] & AllowedBlockPayload>, HydratedBoundWitnessInstance<T> {
 }

package/src/instances/transaction/TransactionFields.ts

@@ -1,14 +1,12 @@
 import type { Hash } from '@xylabs/sdk-js'
-import type {
-  Payload, Schema, WithStorageMeta,
-} from '@xyo-network/payload-model'
+import type { Payload, Schema } from '@xyo-network/payload-model'
 import type { AllowedBlockPayload } from '@xyo-network/xl1-protocol'
 
 import type { TransactionFeesInstance } from '../Fees.ts'
 
 export interface TransactionFieldsInstance<TBlockPayload extends AllowedBlockPayload = AllowedBlockPayload> {
   elevatedPayloadCount: number
-  elevatedPayloads: WithStorageMeta<TBlockPayload>[]
+  elevatedPayloads: TBlockPayload[]
   externalPayloads: Record<Hash, Schema | Payload>
 
   fees: TransactionFeesInstance
@@ -16,6 +14,8 @@ export interface TransactionFieldsInstance<TBlockPayload extends AllowedBlockPay
   privateExternalPayloads: Record<Hash, Schema>
   publicExternalPayloads: Payload[]
 
+  signatureCount: number
+
   elevatedPayload(index: number): TBlockPayload | undefined
   reward(): bigint
 }

package/src/model/PayloadBundle/bundledPayloadToHydratedTransaction.ts

@@ -0,0 +1,14 @@
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { PayloadBundle, WithHashMeta } from '@xyo-network/payload-model'
+import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
+import { asSignedTransactionBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
+
+export const bundledPayloadToHydratedTransaction = async (
+  payload: WithHashMeta<PayloadBundle>,
+): Promise<SignedHydratedTransactionWithHashMeta | undefined> => {
+  const withHashMeta = await PayloadBuilder.addHashMeta(payload.payloads)
+  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find(p => p._hash === payload.root))
+  if (tx) {
+    return [tx, withHashMeta.filter(p => p._hash !== payload.root)]
+  }
+}

package/src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts

@@ -0,0 +1,18 @@
+import type { Hash } from '@xylabs/sdk-js'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { type PayloadBundle, PayloadBundleSchema } from '@xyo-network/payload-model'
+import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
+
+import { flattenHydratedTransaction } from '../../transaction/index.ts'
+
+export const hydratedTransactionToPayloadBundle = (transaction: SignedHydratedTransactionWithHashMeta): PayloadBundle => {
+  const root = transaction[0]._hash
+  return bundle(root, transaction)
+}
+
+const bundle = (root: Hash, transaction: SignedHydratedTransactionWithHashMeta) => {
+  const payloads = flattenHydratedTransaction(transaction).flatMap(p => PayloadBuilder.omitStorageMeta(p))
+  return new PayloadBuilder<PayloadBundle>({ schema: PayloadBundleSchema })
+    .fields({ payloads, root })
+    .build()
+}

package/src/model/PayloadBundle/index.ts

@@ -0,0 +1,2 @@
+export * from './bundledPayloadToHydratedTransaction.ts'
+export * from './hydratedTransactionToPayloadBundle.ts'

package/src/model/index.ts

@@ -2,6 +2,7 @@ export * from './ChainContext/index.ts'
 export * from './ChainFork/index.ts'
 export * from './ChainIdentity.ts'
 export * from './ChainStore.ts'
+export * from './PayloadBundle/index.ts'
 export * from './PayloadMap.ts'
 export * from './Position.ts'
 export * from './RecordKeyType.ts'

package/src/primitives/summary/balances/balancesSummary.ts

@@ -16,7 +16,7 @@ export async function balancesSummary(
   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, headBoundWitness.block],

package/src/primitives/summary/schemas/schemasStepSummaryFromRange.ts

@@ -1,9 +1,10 @@
-/* eslint-disable max-statements */
 import { assertEx } from '@xylabs/sdk-js'
-import { isBoundWitnessWithStorageMeta } from '@xyo-network/boundwitness-model'
+import { isBoundWitness } from '@xyo-network/boundwitness-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Schema, WithStorageMeta } from '@xyo-network/payload-model'
-import { isAnyPayload } from '@xyo-network/payload-model'
+import type {
+  Schema, WithHashMeta, WithStorageMeta,
+} from '@xyo-network/payload-model'
+import { isAnyPayload, isHashMeta } from '@xyo-network/payload-model'
 import type { XL1BlockRange } from '@xyo-network/xl1-protocol'
 import { StepSizes } from '@xyo-network/xl1-protocol'
 
@@ -18,7 +19,7 @@ import { SchemasStepSummarySchema } from '../../../payloads/index.ts'
 export async function schemasStepSummaryFromRange(
   context: SchemasStepSummaryContext,
   range: XL1BlockRange,
-): Promise<WithStorageMeta<SchemasStepSummary>> {
+): Promise<WithHashMeta<SchemasStepSummary>> {
   // console.log(`balanceStepSummaryFromRange: head=${head}, range=${range[0]}-${range[1]}`)
   const frameHeadHash = await hashFromBlockNumber(context, range[1])
   const frameSize = range[1] - range[0] + 1
@@ -29,7 +30,7 @@ export async function schemasStepSummaryFromRange(
   if (frameSize === 1) {
     const hash = await hashFromBlockNumber(context, range[0])
     const [block, payloads] = await hydrateBlock(context.store, hash)
-    const boundWitnesses = [block, ...payloads.filter(isBoundWitnessWithStorageMeta)]
+    const boundWitnesses = [block, ...payloads.filter(x => isBoundWitness(x) && isHashMeta(x))]
     const schemas: Record<Schema, number> = {}
     for (const bw of boundWitnesses) {
       schemas[bw.schema] = (schemas[bw.schema] ?? 0) + 1
@@ -78,6 +79,5 @@ export async function schemasStepSummaryFromRange(
     }
   }
   // console.log(`balanceStepSummaryFromRange-result: head=${head}, range=${range[0]}-${range[1]}: ${toSafeJsonString(result, 10)}`)
-  const finalResult = await PayloadBuilder.addStorageMeta(result)
-  return finalResult
+  return await PayloadBuilder.addHashMeta(result)
 }

package/src/primitives/summary/schemas/schemasSummary.ts

@@ -15,7 +15,7 @@ export async function schemasSummary(
   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, headBoundWitness.block],

package/src/primitives/summary/transfers/transfersSummary.ts

@@ -17,7 +17,7 @@ export async function transfersSummary(
   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, headBoundWitness.block],