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

package/dist/neutral/zod/TransactionFees.d.ts

@@ -0,0 +1,53 @@
+import * as z from 'zod';
+export declare const AttoZod: z.ZodBigInt;
+export declare const JsonToAttoZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+export declare const AttoToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
+export declare const TransactionFeesHexZod: 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.core.$strip>;
+export type TransactionFeesHexZodType = z.infer<typeof TransactionFeesHexZod>;
+export declare const TransactionFeesBigIntZod: z.ZodObject<{
+    base: z.ZodBigInt;
+    gasLimit: z.ZodBigInt;
+    gasPrice: z.ZodBigInt;
+    priority: z.ZodBigInt;
+}, z.core.$strip>;
+export type TransactionFeesBigIntZodType = z.infer<typeof TransactionFeesBigIntZod>;
+export declare const TransactionFeesJsonToBigIntZod: z.ZodPipe<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.core.$strip>, z.ZodTransform<{
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}, {
+    base: import("@xylabs/sdk-js").Hex;
+    gasLimit: import("@xylabs/sdk-js").Hex;
+    gasPrice: import("@xylabs/sdk-js").Hex;
+    priority: import("@xylabs/sdk-js").Hex;
+}>>;
+export declare const TransactionFeesBigIntToJsonZod: z.ZodPipe<z.ZodObject<{
+    base: z.ZodBigInt;
+    gasLimit: z.ZodBigInt;
+    gasPrice: z.ZodBigInt;
+    priority: z.ZodBigInt;
+}, z.core.$strip>, z.ZodTransform<{
+    base: import("@xylabs/sdk-js").Hex;
+    gasLimit: import("@xylabs/sdk-js").Hex;
+    gasPrice: import("@xylabs/sdk-js").Hex;
+    priority: import("@xylabs/sdk-js").Hex;
+}, {
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}>>;
+export type TransactionFeesJsonToBigIntZodType = z.infer<typeof TransactionFeesJsonToBigIntZod>;
+export type TransactionFeesBigIntToJsonZodType = z.infer<typeof TransactionFeesBigIntToJsonZod>;
+//# sourceMappingURL=TransactionFees.d.ts.map

package/dist/neutral/zod/TransactionFees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../src/zod/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,OAAO,aAAa,CAAA;AACjC,eAAO,MAAM,aAAa,+NAA+C,CAAA;AAEzE,eAAO,MAAM,aAAa,8EAAkB,CAAA;AAE5C,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}

package/dist/neutral/zod/TransferPair.d.ts

@@ -0,0 +1,3 @@
+import z from 'zod';
+export declare const TransferPairZod: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
+//# sourceMappingURL=TransferPair.d.ts.map

package/dist/neutral/zod/TransferPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../src/zod/TransferPair.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,eAAe,wLAE1B,CAAA"}

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

@@ -0,0 +1,15 @@
+export * from './ArrayBuffer.ts';
+export * from './BlockBoundWitness.ts';
+export * from './BoundWitness.ts';
+export * from './Chain.ts';
+export * from './HydratedBlock.ts';
+export * from './HydratedTransaction.ts';
+export * from './Permission.ts';
+export * from './RewardsRangeOptions.ts';
+export * from './Sequence.ts';
+export * from './Stake.ts';
+export * from './TimeDomain.ts';
+export * from './TransactionBoundWitness.ts';
+export * from './TransactionFees.ts';
+export * from './TransferPair.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zod/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol-sdk",
-  "version": "1.16.21",
+  "version": "1.16.23",
   "description": "XYO Layer One SDK Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -39,8 +39,8 @@
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/sdk-js": "~5.0.37",
-    "@xylabs/telemetry": "~5.0.37",
+    "@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",
@@ -51,7 +51,7 @@
     "@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.11",
+    "@xyo-network/xl1-protocol": "~1.13.13",
     "async-mutex": "~0.5.0",
     "ethers": "~6.15.0",
     "lru-cache": "^11.2.2",

package/src/ChainServiceCollectionV2.ts

@@ -2,12 +2,12 @@ import type { ArchivistInstance, WriteArchivist } from '@xyo-network/archivist-m
 import type { WalletInstance } from '@xyo-network/wallet-model'
 
 import type {
-  AccountBalanceService, BlockProducerService, BlockRewardService,
+  BlockProducerService, BlockRewardService,
   ChainStaker, ChainStakeViewer, ElectionService, EventingChainBlockNumberIteratorService,
   PendingTransactionsService,
   StakeIntentService,
 } from './services/index.ts'
-import type { ChainContractViewer } from './viewers/index.ts'
+import type { AccountBalanceViewer, ChainContractViewer } from './viewers/index.ts'
 
 export interface ChainServiceCollectionV2 {
 
@@ -18,7 +18,7 @@ export interface ChainServiceCollectionV2 {
   /**
    * Services for working with account balances
    */
-  balance: AccountBalanceService
+  balance: AccountBalanceViewer
   /**
    * The archivist which the chain data is stored in
    */

package/src/block/primitives/index.ts

@@ -4,4 +4,3 @@ export * from './hashFromBlockNumber.ts'
 export * from './model.ts'
 export * from './payloads/index.ts'
 export * from './toStepIdentityString.ts'
-export * from './transfers/index.ts'

package/src/config/Chain.ts

@@ -1,3 +1,4 @@
+import { AddressZod } from '@xylabs/sdk-js'
 import { globalRegistry } from 'zod'
 import * as z from 'zod'
 
@@ -9,6 +10,13 @@ export const ChainConfigZod = z.object({
       title: 'chain.id',
       type: 'string',
     }),
+  genesisRewardAddress: AddressZod.optional()
+    .register(globalRegistry, {
+      description:
+      'Address to send the initial genesis rewards to, if a new chain is being created.',
+      title: 'chain.genesisRewardAddress',
+      type: 'Address',
+    }),
 })
 
 export type ChainConfig = z.infer<typeof ChainConfigZod>

package/src/config/Producer.ts

@@ -16,6 +16,12 @@ 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/index.ts

@@ -16,6 +16,8 @@ export * from './SignedBigInt.ts'
 export * from './simple/index.ts'
 export * from './time/index.ts'
 export * from './transaction/index.ts'
+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'

package/src/model/summary.ts

@@ -2,6 +2,7 @@ import type { Payload } from '@xyo-network/payload-model'
 import type { Semaphore } from 'async-mutex'
 
 import type { MapTypeRead, MapTypeWrite } from '../map/index.ts'
+import type { SchemasStepSummary } from '../payloads/index.ts'
 import type { BalancesStepSummary, TransfersStepSummary } from '../payloads/summary/index.ts'
 import type { BaseContext, ChainContextRead } from './index.ts'
 
@@ -25,3 +26,7 @@ export interface BalanceStepSummaryContext extends ChainSummaryContext<BalancesS
 export interface TransfersStepSummaryContextRead extends ChainSummaryContextRead<TransfersStepSummary> {}
 
 export interface TransfersStepSummaryContext extends ChainSummaryContext<TransfersStepSummary> {}
+
+export interface SchemasStepSummaryContextRead extends ChainSummaryContextRead<SchemasStepSummary> {}
+
+export interface SchemasStepSummaryContext extends ChainSummaryContext<SchemasStepSummary> {}

package/src/payloads/index.ts

@@ -1,4 +1,5 @@
 export * from './AddressPairPayload.ts'
 export * from './netBalancesForPayloads.ts'
+export * from './netSchemasForPayloads.ts'
 export * from './netTransfersForPayloads.ts'
 export * from './summary/index.ts'

package/src/payloads/netSchemasForPayloads.ts

@@ -0,0 +1,22 @@
+import {
+  type Address, type Hex, hexToBigInt, toAddress,
+} from '@xylabs/sdk-js'
+import { span } from '@xylabs/telemetry'
+import type { Payload } from '@xyo-network/payload-model'
+import { isTransfer } from '@xyo-network/xl1-protocol'
+
+export const netSchemasForPayloads = (payloads: Payload[]) => {
+  return span('netSchemasForPayloads', () => {
+    const balances: Record<Address, bigint> = {}
+    for (const payload of payloads) {
+      if (isTransfer(payload)) {
+        const { from } = payload
+        for (let [address, amount] of Object.entries(payload.transfers) as [Address, Hex][]) {
+          balances[toAddress(address)] = (balances[toAddress(address)] ?? 0n) + hexToBigInt(amount)
+          balances[toAddress(from)] = (balances[toAddress(from)] ?? 0n) - hexToBigInt(amount)
+        }
+      }
+    }
+    return balances
+  })
+}

package/src/payloads/summary/SchemasStepSummary.ts

@@ -0,0 +1,26 @@
+import { AsObjectFactory } from '@xylabs/sdk-js'
+import type { Schema, WithStorageMeta } from '@xyo-network/payload-model'
+import { isPayloadOfSchemaType, isStorageMeta } from '@xyo-network/payload-model'
+
+import type { StepSummary } from './StepSummary.ts'
+
+export const SchemasStepSummarySchema: Schema = 'network.xyo.step.summary.schemas'
+export type SchemasStepSummarySchema = typeof SchemasStepSummarySchema
+
+export type SchemasStepSummary = StepSummary<{
+  schemas: Record<Schema, number>
+}, SchemasStepSummarySchema>
+
+/**
+ * Identity function for determining if an object is an SchemasStepSummary
+ */
+export const isSchemasStepSummary = isPayloadOfSchemaType<SchemasStepSummary>(SchemasStepSummarySchema)
+export const asSchemasStepSummary = AsObjectFactory.create<SchemasStepSummary>(isSchemasStepSummary)
+
+/**
+ * Identity function for determining if an object is an SchemasStepSummary with Storage Meta
+ */
+export const isSchemasStepSummaryWithStorageMeta = (value: unknown): value is WithStorageMeta<SchemasStepSummary> => {
+  return isSchemasStepSummary(value) && isStorageMeta(value)
+}
+export const asSchemasStepSummaryWithStorageMeta = AsObjectFactory.create<WithStorageMeta<SchemasStepSummary>>(isSchemasStepSummaryWithStorageMeta)

package/src/payloads/summary/index.ts

@@ -1,3 +1,4 @@
 export * from './BalancesStepSummary.ts'
+export * from './SchemasStepSummary.ts'
 export * from './StepSummary.ts'
 export * from './TransfersSummary.ts'

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

@@ -13,7 +13,7 @@ import { balancesStepSummaryFromRange } from './balancesStepSummaryFromRange.ts'
 export async function balancesSummary(
   context: BalanceStepSummaryContext,
 ): Promise<Partial<Record<Address, bigint>>> {
-  return await spanRootAsync('balanceSummary', async () => {
+  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 })

package/src/primitives/summary/index.ts

@@ -1,2 +1,3 @@
 export * from './balances/index.ts'
-export * from './balances/index.ts'
+export * from './schemas/index.ts'
+export * from './transfers/index.ts'

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

@@ -0,0 +1,2 @@
+export * from './schemasStepSummaryFromRange.ts'
+export * from './schemasSummary.ts'

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

@@ -0,0 +1,83 @@
+/* eslint-disable max-statements */
+import { assertEx } from '@xylabs/sdk-js'
+import { isBoundWitnessWithStorageMeta } 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 { XL1BlockRange } from '@xyo-network/xl1-protocol'
+import { StepSizes } from '@xyo-network/xl1-protocol'
+
+import {
+  deepCalculateFramesFromRange, hashFromBlockNumber,
+  hydrateBlock,
+} from '../../../block/index.ts'
+import type { SchemasStepSummaryContext } from '../../../model/index.ts'
+import type { SchemasStepSummary } from '../../../payloads/index.ts'
+import { SchemasStepSummarySchema } from '../../../payloads/index.ts'
+
+export async function schemasStepSummaryFromRange(
+  context: SchemasStepSummaryContext,
+  range: XL1BlockRange,
+): Promise<WithStorageMeta<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
+  const [headHash] = await context.head()
+
+  let result: SchemasStepSummary | undefined = undefined
+
+  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 schemas: Record<Schema, number> = {}
+    for (const bw of boundWitnesses) {
+      schemas[bw.schema] = (schemas[bw.schema] ?? 0) + 1
+      for (const schema of bw.payload_schemas) {
+        schemas[schema] = (schemas[schema] ?? 0) + 1
+      }
+    }
+    result = {
+      schema: SchemasStepSummarySchema, hash: headHash, stepSize: -1, schemas,
+    }
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const step = (StepSizes as any).indexOf(frameSize)
+    assertEx(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes.join(', ')}`)
+
+    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`)
+    if (isAnyPayload(summaryResult)) {
+      result = summaryResult as WithStorageMeta<SchemasStepSummary>
+    } else {
+    // We do not have it, so lets build it
+      await context.stepSemaphores[step].acquire()
+      try {
+        const subRanges = deepCalculateFramesFromRange(range, step - 1)
+        const promises = subRanges.map(subRange => schemasStepSummaryFromRange(
+          context,
+          subRange,
+        ))
+        const subResults = await Promise.all(promises)
+
+        // add them all up
+        const schemas: Record<Schema, number> = {}
+        for (const subResult of subResults) {
+          for (const [schema, count] of Object.entries(subResult.schemas)) {
+            schemas[schema] = (schemas[schema] ?? 0) + count
+          }
+        }
+
+        result = {
+          schema: SchemasStepSummarySchema, hash: frameHeadHash, stepSize: frameSize, schemas: schemas,
+        }
+
+        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result)
+      } finally {
+        context.stepSemaphores[step].release()
+      }
+    }
+  }
+  // console.log(`balanceStepSummaryFromRange-result: head=${head}, range=${range[0]}-${range[1]}: ${toSafeJsonString(result, 10)}`)
+  const finalResult = await PayloadBuilder.addStorageMeta(result)
+  return finalResult
+}

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

@@ -0,0 +1,33 @@
+import { isDefined } from '@xylabs/sdk-js'
+import { spanRootAsync } from '@xylabs/telemetry'
+import type { Schema } from '@xyo-network/payload-model'
+import {
+  asBlockBoundWitnessWithStorageMeta, asXL1BlockNumber, asXL1BlockRange,
+} from '@xyo-network/xl1-protocol'
+
+import { deepCalculateFramesFromRange } from '../../../block/index.ts'
+import type { SchemasStepSummaryContext } from '../../../model/index.ts'
+import { schemasStepSummaryFromRange } from './schemasStepSummaryFromRange.ts'
+
+export async function schemasSummary(
+  context: SchemasStepSummaryContext,
+): Promise<Partial<Record<Schema, number>>> {
+  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 rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0)
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange(
+      [rangeStart, headBoundWitness.block],
+      { name: 'schemasSummary' },
+    ))
+    const summaries = await Promise.all(ranges.map(range => schemasStepSummaryFromRange(context, range)))
+    const schemas: Partial<Record<Schema, number>> = {}
+    for (let summary of summaries) {
+      for (const [schema, count] of Object.entries(summary.schemas)) {
+        schemas[schema] = (schemas[schema] ?? 0) + count
+      }
+    }
+    return schemas
+  })
+}

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

@@ -8,8 +8,7 @@ import type { XL1BlockRange } from '@xyo-network/xl1-protocol'
 import { StepSizes } from '@xyo-network/xl1-protocol'
 
 import {
-  deepCalculateFramesFromRange,
-  hashFromBlockNumber, hydrateBlock,
+  deepCalculateFramesFromRange, hashFromBlockNumber, hydrateBlock,
 } from '../../../block/index.ts'
 import type { TransfersStepSummaryContext } from '../../../model/index.ts'
 import type { TransfersStepSummary } from '../../../payloads/index.ts'
@@ -17,12 +16,13 @@ import { netTransfersForPayloads, TransfersStepSummarySchema } from '../../../pa
 import {
   parseSignedBigInt, type SignedBigInt, toSignedBigInt,
 } from '../../../SignedBigInt.ts'
+import { transfersSummaryKey } from './transfersSummary.ts'
 
 export async function transfersStepSummaryFromRange(
   context: TransfersStepSummaryContext,
   range: XL1BlockRange,
 ): Promise<WithStorageMeta<TransfersStepSummary>> {
-  // console.log(`transfersStepSummaryFromRange: head=${head}, range=${range[0]}-${range[1]}`)
+  // console.log(`transfersStepSummaryFromRange: head=${context.head}, range=${range[0]}-${range[1]}`)
   const frameHeadHash = await hashFromBlockNumber(context, range[1])
   const frameSize = range[1] - range[0] + 1
   const [headHash] = await context.head()
@@ -47,7 +47,9 @@ export async function transfersStepSummaryFromRange(
     const step = (StepSizes as any).indexOf(frameSize)
     assertEx(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes.join(', ')}`)
 
-    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`)
+    const key = transfersSummaryKey(frameHeadHash, frameSize)
+
+    const summaryResult = await context.summaryMap.get(key)
     if (isAnyPayload(summaryResult)) {
       result = summaryResult as WithStorageMeta<TransfersStepSummary>
     } else {
@@ -84,13 +86,13 @@ export async function transfersStepSummaryFromRange(
           schema: TransfersStepSummarySchema, hash: frameHeadHash, stepSize: frameSize, transfers,
         }
 
-        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result)
+        await context.summaryMap.set(key, result)
       } finally {
         context.stepSemaphores[step].release()
       }
     }
   }
-  // console.log(`transfersStepSummaryFromRange-result: head=${head}, range=${range[0]}-${range[1]}: ${toSafeJsonString(result, 10)}`)
+  // console.log(`transfersStepSummaryFromRange-result: head=${context.head}, range=${range[0]}-${range[1]}: ${toSafeJsonString(result, 10)}`)
   const finalResult = await PayloadBuilder.addStorageMeta(result)
   return finalResult
 }

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

@@ -1,4 +1,4 @@
-import type { Address } from '@xylabs/sdk-js'
+import type { Address, Hash } from '@xylabs/sdk-js'
 import { asAddress, isDefined } from '@xylabs/sdk-js'
 import { spanRootAsync } from '@xylabs/telemetry'
 import {
@@ -12,18 +12,18 @@ import { transfersStepSummaryFromRange } from './transfersStepSummaryFromRange.t
 
 // the summary of amount of rewards claimed from the step reward pool by addresses
 export async function transfersSummary(
-  context: TransfersStepSummaryContext,
+  transferContext: TransfersStepSummaryContext,
 ): Promise<Partial<Record<Address, Partial<Record<Address, bigint>>>>> {
   return await spanRootAsync('transferSummary', 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 rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0)
+    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 rangeStart = asXL1BlockNumber(isDefined(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0)
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange(
       [rangeStart, headBoundWitness.block],
       { name: 'transfersSummary' },
     ))
-    const summaries = await Promise.all(ranges.map(range => transfersStepSummaryFromRange(context, range)))
+    const summaries = await Promise.all(ranges.map(range => transfersStepSummaryFromRange(transferContext, range)))
     const transfers: Partial<Record<Address, Partial<Record<Address, bigint>>>> = {}
     for (let summary of summaries) {
       for (const [from, toMap] of Object.entries(summary.transfers)) {
@@ -38,3 +38,7 @@ export async function transfersSummary(
     return transfers
   })
 }
+
+export function transfersSummaryKey(frameHeadHash: Hash, frameSize: number) {
+  return `${frameHeadHash}|${frameSize}`
+}

package/src/primitives/timeBudget.ts

@@ -1,11 +1,30 @@
 import { type Logger } from '@xylabs/sdk-js'
 
-export async function timeBudget<TResult>(name: string, logger: Logger | undefined, func: () => Promise<TResult>, budget: number): Promise<TResult> {
+export async function timeBudget<TResult>(
+  name: string,
+  logger: Logger | undefined,
+  func: () => Promise<TResult>,
+  budget: number,
+  status = false,
+): Promise<TResult> {
   const start = Date.now()
+  const timer = status
+    ? setInterval(() => {
+        const duration = Date.now() - start
+        if ((budget > 0) && (duration > budget)) {
+          logger?.warn(`Function [${name}] execution is exceeding budget: ${duration}ms > ${budget}ms`)
+        }
+      }, Math.max(100, budget))
+    : undefined
+
   const result = await func()
   const duration = Date.now() - start
-  if ((budget > 0) && (duration > budget)) {
+
+  if (!timer && (budget > 0) && (duration > budget)) {
     logger?.warn(`Function [${name}] execution exceeded budget: ${duration}ms > ${budget}ms`)
   }
+  if (timer) {
+    clearInterval(timer)
+  }
   return result
 }

package/src/services/SchemasService.ts

@@ -0,0 +1,9 @@
+import type { Hash, Promisable } from '@xylabs/sdk-js'
+import type { Schema } from '@xyo-network/payload-model'
+
+export interface SchemasProvider {
+  schema(head: Hash, schema: Schema): Promisable<number>
+  schemas(head: Hash, schemas: Schema[]): Promisable<Partial<Record<Schema, number>>>
+}
+
+export interface SchemasService extends SchemasProvider {}

package/src/services/index.ts

@@ -1,4 +1,3 @@
-export * from './AccountBalanceService.ts'
 export * from './AccountTransfersService.ts'
 export * from './BlockProducerService.ts'
 export * from './BlockRewardService.ts'
@@ -8,4 +7,5 @@ export * from './ChainIterator/index.ts'
 export * from './Election.ts'
 export * from './NetworkStakeService.ts'
 export * from './PendingTransactionsService.ts'
+export * from './SchemasService.ts'
 export * from './StakeIntentService/index.ts'

package/src/simple/accountBalance/SimpleAccountBalanceViewer.ts

@@ -14,10 +14,10 @@ import {
   TransferSchema,
 } from '@xyo-network/xl1-protocol'
 
-import { deepCalculateFramesFromRange, transfersStepSummaryFromRange } from '../../block/index.ts'
+import { deepCalculateFramesFromRange } from '../../block/index.ts'
 import type { BalanceStepSummaryContext, TransfersStepSummaryContext } from '../../model/index.ts'
 import type { TransfersStepSummary } from '../../payloads/index.ts'
-import { balancesSummary } from '../../primitives/index.ts'
+import { balancesSummary, transfersStepSummaryFromRange } from '../../primitives/index.ts'
 import type {
   AccountBalanceHistoryItem, AccountBalanceViewer, BlockViewer,
 } from '../../viewers/index.ts'
@@ -34,7 +34,7 @@ export class SimpleAccountBalanceViewer implements AccountBalanceViewer {
   }
 
   async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
-    const balances = await this.accountBalances([address], headOrRange)
+    const balances = await this.accountsBalances([address], headOrRange)
     return balances[address] ?? AttoXL1(0n)
   }
 
@@ -66,7 +66,7 @@ export class SimpleAccountBalanceViewer implements AccountBalanceViewer {
     return result
   }
 
-  async accountBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AttoXL1>>> {
+  async accountsBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AttoXL1>>> {
     return await spanRootAsync('balances', async () => {
       const summary = await balancesSummary(
         this.context,
@@ -80,7 +80,7 @@ export class SimpleAccountBalanceViewer implements AccountBalanceViewer {
     })
   }
 
-  accountBalancesHistories(_addresses: Address[], _rangeOrHash?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
+  accountsBalancesHistory(_addresses: Address[], _rangeOrHash?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
     throw new Error('Method not implemented.')
   }
 

package/src/simple/chainStake/SimpleChainStakeViewer.ts

@@ -36,7 +36,7 @@ export class SimpleChainStakeViewer extends AbstractCreatable<SimpleChainStakePa
   }
 
   get rewardsContract(): Address {
-    return toAddress('0x000000000000000000000000000000')
+    return toAddress(toAddress(1n))
   }
 
   get stakeEvents() {

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './isZodError.ts'

package/src/utils/isZodError.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod'
+
+export const isZodError = (error: unknown): error is z.ZodError => {
+  return error instanceof z.ZodError
+}
+
+export const prettifyZodError = (error: z.ZodError): string => {
+  return z.prettifyError(error)
+}

package/src/validation/block/HydratedBlockStateValidationFunction.ts

@@ -1,7 +1,7 @@
 import type { Promisable } from '@xylabs/sdk-js'
 import type { ChainId, HydratedBlock } from '@xyo-network/xl1-protocol'
 
-import type { AccountBalanceService } from '../../services/index.ts'
+import type { AccountBalanceViewer } from '../../viewers/index.ts'
 import type { HydratedBlockStateValidationError } from './error.ts'
 
 /**
@@ -14,5 +14,5 @@ import type { HydratedBlockStateValidationError } from './error.ts'
 export type HydratedBlockStateValidationFunction = (
   hydratedBlock: HydratedBlock,
   chainId: ChainId,
-  services: { accountBalance: AccountBalanceService },
+  services: { accountBalance: AccountBalanceViewer },
 ) => Promisable<HydratedBlockStateValidationError[]>