@xyo-network/xl1-protocol-sdk 1.5.35 → 1.5.36

package/src/ChainServiceCollection.ts

@@ -0,0 +1,65 @@
+import type { ArchivistInstance, WriteArchivist } from '@xyo-network/archivist-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  AccountBalanceService, BlockProducerService,
+  BlockRewardService, ChainContractViewer, ChainStaker, ChainStakeViewer, ElectionService, EventingChainBlockNumberIterator,
+  StakeIntentService,
+} from '@xyo-network/xl1-protocol'
+
+export interface ChainServiceCollection {
+
+  /**
+   * The account which is used to sign transactions
+   */
+  account: WalletInstance
+  /**
+   * Services for working with account balances
+   */
+  balanceService: AccountBalanceService
+  /**
+   * The archivist which the chain data is stored in
+   */
+  chainArchivist: ArchivistInstance
+  /**
+   * Service for viewing codified chain information
+   * from a contract
+   */
+  chainContractViewer: ChainContractViewer
+  /**
+   * The chain iterator
+   */
+  chainIterator?: EventingChainBlockNumberIterator
+  /**
+   * Service for viewing stake information
+   */
+  chainStakeViewer: ChainStakeViewer
+  /**
+   * Service for staking
+   */
+  chainStaker: ChainStaker
+  /**
+   * The archivist which the chain submissions are stored in
+   */
+  chainSubmissionsArchivistWrite: WriteArchivist
+  /**
+   * Service for determining leader election
+   */
+  electionService: ElectionService
+  /**
+   * The archivist which the pending transactions are stored
+   * as bundled transactions
+   */
+  pendingBundledTransactionsArchivistWrite: ArchivistInstance
+  /**
+   * The block producer service
+   */
+  producer: BlockProducerService
+  /**
+   * Service response for calculating block rewards
+   */
+  rewardService: BlockRewardService
+  /**
+   * Services for working with staked intents
+   */
+  stakeIntentService: StakeIntentService
+}

package/src/ChainServiceCollectionV2.ts

@@ -0,0 +1,65 @@
+import type { ArchivistInstance, WriteArchivist } from '@xyo-network/archivist-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  AccountBalanceServiceV2, BlockProducerService,
+  BlockRewardService, ChainContractViewer, ChainStaker, ChainStakeViewer, ElectionService, EventingChainBlockNumberIterator,
+  StakeIntentService,
+} from '@xyo-network/xl1-protocol'
+
+export interface ChainServiceCollectionV2 {
+
+  /**
+   * The account which is used to sign transactions
+   */
+  account: WalletInstance
+  /**
+   * Services for working with account balances
+   */
+  balanceService: AccountBalanceServiceV2
+  /**
+   * The archivist which the chain data is stored in
+   */
+  chainArchivist: ArchivistInstance
+  /**
+   * Service for viewing codified chain information
+   * from a contract
+   */
+  chainContractViewer: ChainContractViewer
+  /**
+   * The chain iterator
+   */
+  chainIterator?: EventingChainBlockNumberIterator
+  /**
+   * Service for viewing stake information
+   */
+  chainStakeViewer: ChainStakeViewer
+  /**
+   * Service for staking
+   */
+  chainStaker: ChainStaker
+  /**
+   * The archivist which the chain submissions are stored in
+   */
+  chainSubmissionsArchivistWrite: WriteArchivist
+  /**
+   * Service for determining leader election
+   */
+  electionService: ElectionService
+  /**
+   * The archivist which the pending transactions are stored
+   * as bundled transactions
+   */
+  pendingBundledTransactionsArchivistWrite: ArchivistInstance
+  /**
+   * The block producer service
+   */
+  producer: BlockProducerService
+  /**
+   * Service response for calculating block rewards
+   */
+  rewardService: BlockRewardService
+  /**
+   * Services for working with staked intents
+   */
+  stakeIntentService: StakeIntentService
+}

package/src/SignedBigInt.ts

@@ -0,0 +1,51 @@
+import {
+  type Hex,
+  hexToBigInt,
+  toHex,
+} from '@xylabs/hex'
+import { isObject } from '@xylabs/object'
+
+export interface NegativeBigInt {
+  negative: Hex
+}
+
+export interface PositiveBigInt {
+  positive: Hex
+}
+
+export type SignedBigInt = NegativeBigInt | PositiveBigInt
+
+export const isNegativeBigInt = (value: unknown): value is NegativeBigInt => {
+  return isObject(value) && 'negative' in value && typeof value.negative === 'string'
+}
+
+export const isPositiveBigInt = (value: unknown): value is PositiveBigInt => {
+  return isObject(value) && 'positive' in value && typeof value.positive === 'string'
+}
+
+export const parseSignedBigInt = (value: SignedBigInt): bigint => {
+  if (isNegativeBigInt(value)) {
+    return -hexToBigInt(value.negative)
+  } else if (isPositiveBigInt(value)) {
+    return hexToBigInt(value.positive)
+  } else {
+    throw new Error('Invalid balance type')
+  }
+}
+
+export const toSignedBigInt = (value: bigint): SignedBigInt => {
+  return value < 0n ? { negative: toHex(-value) } : { positive: toHex(value) }
+}
+
+export const toPositiveBigInt = (value: unknown): PositiveBigInt => {
+  if (isNegativeBigInt(value)) {
+    return { positive: toHex(0n) }
+  }
+  if (isPositiveBigInt(value)) {
+    return { positive: value.positive }
+  }
+  if (typeof value === 'bigint') {
+    return { positive: toHex(value) }
+  }
+  throw new Error('Invalid value for positive big int')
+}

package/src/block/hydrateBlock.ts

@@ -17,27 +17,28 @@ export const tryHydrateBlock = async (
   archivist: ReadArchivist,
   hash: Hash,
   maxDepth: number = 1,
-  minDepth?: number,
 ): Promise<HydratedBlock | undefined> => {
-  try {
-    return await hydrateBlock(archivist, hash, maxDepth, minDepth)
-  } catch (e) {
-    if (e instanceof Error) {
-      console.warn(`Failed to hydrate block ${hash}: ${e.message}`)
-    } else {
-      console.warn(`Failed to hydrate block ${hash}: ${e}`)
-    }
-    return undefined
-  }
+  assertEx(maxDepth >= 0, () => 'maxDepth must be greater than or equal to 0')
+  const bw = filterAs(await archivist.get([hash]), asBlockBoundWitnessWithStorageMeta).at(0)
+  if (!bw) return undefined
+  if (maxDepth === 0) return [bw, []]
+  const blkPayloads = await archivist.get(bw.payload_hashes)
+  if (maxDepth === 1) return [bw, blkPayloads]
+  const transactions = filterAs(blkPayloads, asTransactionBoundWitnessWithStorageMeta)
+  const transactionsPayloadHashes = transactions.flatMap(tx => tx.payload_hashes)
+  const transactionsPayloads = await archivist.get(transactionsPayloadHashes)
+  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap(p => p._hash))
+  const allPayloads = await archivist.get([...allPayloadsHashes])
+  const allPayloadsFiltered = allPayloads.filter(p => allPayloadsHashes.has(p._hash))
+  return [bw, allPayloadsFiltered]
 }
 
 export const hydrateBlock = async (
   archivist: ReadArchivist,
   hash: Hash,
   maxDepth: number = 1,
-  minDepth?: number,
+  minDepth = maxDepth,
 ): Promise<HydratedBlock> => {
-  if (minDepth === undefined) minDepth = maxDepth
   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/primitives/balanceStepSummaryFromRange.ts

@@ -0,0 +1,78 @@
+import { assertEx } from '@xylabs/assert'
+import { type Address } from '@xylabs/hex'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import { isAnyPayload } from '@xyo-network/payload-model'
+import { StepSizes } from '@xyo-network/xl1-protocol'
+
+import { netBalancesForPayloads } from '../../payload/netBalancesForPayloads.ts'
+import {
+  parseSignedBigInt, type SignedBigInt, toSignedBigInt,
+} from '../../SignedBigInt.ts'
+import { hydrateBlock } from '../hydrateBlock.ts'
+import type { BlockNumberRange } from './frames/BlockNumberRange.ts'
+import { deepCalculateFramesFromRange } from './frames/deepCalculateFramesFromRange.ts'
+import { hashFromBlockNumber } from './hashFromBlockNumber.ts'
+import type { BalanceStepSummaryContext } from './model.ts'
+import { type BalancesStepSummary, BalancesStepSummarySchema } from './payloads.ts'
+
+export async function balanceStepSummaryFromRange(
+  context: BalanceStepSummaryContext,
+  range: BlockNumberRange,
+): Promise<WithStorageMeta<BalancesStepSummary>> {
+  // console.log(`balanceStepSummaryFromRange: head=${head}, range=${range[0]}-${range[1]}`)
+  const frameHeadHash = await hashFromBlockNumber(context, range[1])
+  const frameSize = range[1] - range[0] + 1
+
+  let result: BalancesStepSummary | undefined = undefined
+
+  if (frameSize === 1) {
+    const [, payloads] = await hydrateBlock(context.chainArchivist, context.head)
+    const balances: Record<Address, SignedBigInt> = {}
+    for (const [address, balance] of Object.entries(netBalancesForPayloads(payloads))) {
+      balances[address as Address] = toSignedBigInt(balance)
+    }
+    result = {
+      schema: BalancesStepSummarySchema, hash: context.head, stepSize: -1, balances,
+    }
+  } 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.summaryRepository.get([frameHeadHash])
+    if (isAnyPayload(summaryResult)) {
+      result = summaryResult as WithStorageMeta<BalancesStepSummary>
+    } else {
+    // We do not have it, so lets build it
+      const subRanges = deepCalculateFramesFromRange(range, step - 1)
+      const promises = subRanges.map(subRange => balanceStepSummaryFromRange(
+        context,
+        subRange,
+      ))
+      const subResults = await Promise.all(promises)
+
+      // add them all up
+      const bigIntBalances: Record<Address, bigint> = {}
+      for (const subResult of subResults) {
+        for (const [address, balance] of Object.entries(subResult.balances)) {
+          bigIntBalances[address as Address] = (bigIntBalances[address as Address] ?? 0n) + parseSignedBigInt(balance)
+        }
+      }
+
+      const balances: Record<Address, SignedBigInt> = {}
+      for (const [address, balance] of Object.entries(bigIntBalances)) {
+        balances[address as Address] = toSignedBigInt(balance)
+      }
+
+      result = {
+        schema: BalancesStepSummarySchema, hash: frameHeadHash, stepSize: frameSize, balances,
+      }
+
+      await context.summaryRepository.insert([result])
+    }
+  }
+  // console.log(`balanceStepSummaryFromRange-result: head=${head}, range=${range[0]}-${range[1]}: ${toJsonString(result, 10)}`)
+  const finalResult = await PayloadBuilder.addStorageMeta(result)
+  return finalResult
+}

package/src/block/primitives/balanceSummary.ts

@@ -0,0 +1,27 @@
+import type { Address } from '@xylabs/hex'
+import { asAddress } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import { asBlockBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+
+import { parseSignedBigInt } from '../../SignedBigInt.ts'
+import { balanceStepSummaryFromRange } from './balanceStepSummaryFromRange.ts'
+import { deepCalculateFramesFromRange } from './frames/deepCalculateFramesFromRange.ts'
+import type { BalanceStepSummaryContext } from './model.ts'
+
+export async function balanceSummary(
+  context: BalanceStepSummaryContext,
+): Promise<Partial<Record<Address, bigint>>> {
+  const headResult = await context.chainArchivist.get([context.head])
+  const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult.at(0), () => `Head block not found for hash: ${context.head}`, { required: true })
+  const rangeStart = isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0
+  const ranges = deepCalculateFramesFromRange([rangeStart, headBoundWitness.block])
+  const summaries = await Promise.all(ranges.map(range => balanceStepSummaryFromRange(context, range)))
+  const balances: Partial<Record<Address, bigint>> = {}
+  for (let summary of summaries) {
+    for (const [address, balance] of Object.entries(summary.balances)) {
+      const validAddress = asAddress(address, () => `Invalid address: ${address}`)
+      balances[validAddress] = (balances[validAddress] ?? 0n) + parseSignedBigInt(balance)
+    }
+  }
+  return balances
+}

package/src/block/primitives/frames/calculateFramesFromRange.ts

@@ -1,4 +1,4 @@
-import { stepSizeV2 } from '@xyo-network/xl1-protocol'
+import { stepSize } from '@xyo-network/xl1-protocol'
 
 import type { BlockNumberRange } from './BlockNumberRange.ts'
 
@@ -7,7 +7,7 @@ export function calculateFramesFromRange(range: BlockNumberRange, step: number):
   BlockNumberRange[],
   // ranges of remaining blocks
   BlockNumberRange[]] {
-  const size = stepSizeV2(step)
+  const size = stepSize(step)
   let start = (Math.trunc(range[0] / size)) * size
   const fitted: BlockNumberRange[] = []
   const remaining: BlockNumberRange[] = []

package/src/block/primitives/frames/deepCalculateFramesFromRange.ts

@@ -1,9 +1,9 @@
-import { StepSizesV2 } from '@xyo-network/xl1-protocol'
+import { StepSizes } from '@xyo-network/xl1-protocol'
 
 import type { BlockNumberRange } from './BlockNumberRange.ts'
 import { calculateFramesFromRange } from './calculateFramesFromRange.ts'
 
-export function deepCalculateFramesFromRange(range: BlockNumberRange, startingStep = StepSizesV2.length - 1): BlockNumberRange[] {
+export function deepCalculateFramesFromRange(range: BlockNumberRange, startingStep = StepSizes.length - 1): BlockNumberRange[] {
   const fitted: BlockNumberRange[] = []
   let remaining: BlockNumberRange[] = [range]
 

package/src/block/primitives/frames/index.ts

@@ -1,2 +1,3 @@
 export * from './BlockNumberRange.ts'
-export * from './stepHashFramesFromBlock.ts'
+export * from './calculateFramesFromRange.ts'
+export * from './deepCalculateFramesFromRange.ts'

package/src/block/primitives/hashFromBlockNumber.ts

@@ -0,0 +1,31 @@
+import { asHash, type Hash } from '@xylabs/hex'
+import { toJsonString } from '@xylabs/object'
+import { asBlockBoundWitnessWithStorageMeta, StepSizes } from '@xyo-network/xl1-protocol'
+
+import type { ChainContext } from './model.ts'
+
+export async function hashFromBlockNumber(context: ChainContext, blockNumber: number): Promise<Hash> {
+  const result = await context.chainArchivist.get([context.head])
+  let currentBlock = asBlockBoundWitnessWithStorageMeta(result.at(0), () => `Head block not found for hash: ${context.head}`, { required: true })
+  while (currentBlock.block > blockNumber) {
+    let jumpHash: Hash | null = currentBlock.previous
+    let jumpBlockNumber = currentBlock.block - 1
+    for (const [step, stepSize] of StepSizes.entries()) {
+      const possibleJumpBlockNumber = currentBlock.block - stepSize
+      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}`)
+      }
+    }
+    const [newBlock] = await context.chainArchivist.get([
+      asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toJsonString(currentBlock, 10)}`)])
+    currentBlock = asBlockBoundWitnessWithStorageMeta(newBlock, () => `Block not found for hash: ${jumpHash}`, { required: true })
+    if (currentBlock.block === blockNumber) {
+      break
+    }
+    if (currentBlock.block < blockNumber) {
+      throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${context.head}.`)
+    }
+  }
+  return currentBlock._hash
+}

package/src/block/primitives/index.ts

@@ -1 +1,6 @@
+export * from './balanceStepSummaryFromRange.ts'
+export * from './balanceSummary.ts'
 export * from './frames/index.ts'
+export * from './hashFromBlockNumber.ts'
+export * from './model.ts'
+export * from './payloads.ts'

package/src/block/primitives/model.ts

@@ -0,0 +1,18 @@
+import type { Hash } from '@xylabs/hex'
+import type { ReadArchivist } from '@xyo-network/archivist-model'
+import type { Payload } from '@xyo-network/payload-model'
+import type { PayloadRepository } from '@xyo-network/xl1-protocol'
+
+import type { BalancesStepSummary } from './payloads.ts'
+
+export interface ChainContext {
+  chainArchivist: ReadArchivist
+  head: Hash
+  windowSize?: number
+}
+
+export interface ChainSummaryContext<T extends Payload> extends ChainContext {
+  summaryRepository: PayloadRepository<Hash, T>
+}
+
+export interface BalanceStepSummaryContext extends ChainSummaryContext<BalancesStepSummary> {}

package/src/block/primitives/payloads.ts

@@ -0,0 +1,29 @@
+import type { Address, Hash } from '@xylabs/hex'
+import type { EmptyObject } from '@xylabs/object'
+import type { Payload, Schema } from '@xyo-network/payload-model'
+
+import type { SignedBigInt } from '../../SignedBigInt.ts'
+
+export const StepSummarySchema: Schema = 'network.xyo.step.summary'
+export type StepSummarySchema = typeof StepSummarySchema
+
+export interface StepSummaryFields {
+  hash: Hash // the stepHash - the hash of the last block in the step frame
+  stepSize: number // the stepSize in blocks
+}
+
+export interface ChainWindow {
+  depth: number // number of blocks the window covers, including the head
+  head: Hash // the head of the chain
+}
+
+export type StepSummary<TAdditionalFields extends EmptyObject | void = void,
+  TSchema extends Schema | void = void> = Payload<TAdditionalFields extends void ? StepSummaryFields : TAdditionalFields & StepSummaryFields,
+    TSchema extends void ? StepSummarySchema : TSchema>
+
+export const BalancesStepSummarySchema: Schema = 'network.xyo.step.summary.balances'
+export type BalancesStepSummarySchema = typeof BalancesStepSummarySchema
+
+export type BalancesStepSummary = StepSummary<{
+  balances: Record<Address, SignedBigInt>
+}, BalancesStepSummarySchema>

package/src/index.ts

@@ -1,3 +1,7 @@
 export * from './block/index.ts'
+export * from './ChainServiceCollection.ts'
+export * from './ChainServiceCollectionV2.ts'
 export * from './instances/index.ts'
+export * from './payload/index.ts'
+export * from './SignedBigInt.ts'
 export * from './transaction/index.ts'

package/src/payload/index.ts

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

package/src/payload/netBalancesForPayloads.ts

@@ -0,0 +1,19 @@
+import {
+  type Address, type Hex, hexToBigInt, toAddress,
+} from '@xylabs/hex'
+import type { Payload } from '@xyo-network/payload-model'
+import { isTransfer } from '@xyo-network/xl1-protocol'
+
+export const netBalancesForPayloads = (payloads: Payload[]) => {
+  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/transaction/buildTransaction.ts

@@ -5,11 +5,13 @@ import type { AccountInstance } from '@xyo-network/account-model'
 import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { Payload } from '@xyo-network/payload-model'
-import {
-  type AllowedBlockPayload,
-  defaultTransactionFees,
-  type HydratedTransaction, type TransactionBoundWitness, type TransactionBoundWitnessFields, type TransactionFeesBigInt,
+import type {
+  AllowedBlockPayload,
+  ExecutableFields,
+  FromFields,
+  HydratedTransaction, TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt,
 } from '@xyo-network/xl1-protocol'
+import { defaultTransactionFees } from '@xyo-network/xl1-protocol'
 
 export async function buildTransaction(
   chain: Address,
@@ -43,12 +45,17 @@ export async function buildTransaction(
     script.push(`elevate|${elevatedHash}`)
   }
 
+  const fields: TransactionBoundWitnessFields & FromFields & Partial<ExecutableFields> = {
+    ...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<TransactionBoundWitness>()
-    .fields({
-      ...txBoundWitnessFields,
-      script,
-      from: from ?? (Array.isArray(signer) ? assertEx(signer.at(0)?.address) : signer.address),
-    })
+    .fields(fields)
     .meta({ $signatures: [] })
     .payloads([...elevatedPayloads, ...additionalPayloads])
     .signers(Array.isArray(signer) ? signer : [signer])

package/dist/types/block/primitives/frames/loadFrameSummaries.d.ts

@@ -1,5 +0,0 @@
-import type { ArchivistInstance } from '@xyo-network/archivist-model';
-import type { Payload } from '@xyo-network/payload-model';
-import type { BlockNumberRange } from './BlockNumberRange.ts';
-export declare function loadFrameSummaries(ranges: BlockNumberRange[], finalizedArchivist: ArchivistInstance, summaryArchivist: ArchivistInstance): Promise<Payload[]>;
-//# sourceMappingURL=loadFrameSummaries.d.ts.map

package/dist/types/block/primitives/frames/loadFrameSummaries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadFrameSummaries.d.ts","sourceRoot":"","sources":["../../../../../src/block/primitives/frames/loadFrameSummaries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,gBAAgB,EAAE,EAC1B,kBAAkB,EAAE,iBAAiB,EACrC,gBAAgB,EAAE,iBAAiB,GAClC,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB"}

package/dist/types/block/primitives/frames/stepHashFramesFromBlock.d.ts

@@ -1,5 +0,0 @@
-import { type Hash } from '@xylabs/hex';
-import type { ArchivistInstance } from '@xyo-network/archivist-model';
-export declare function stepHashFramesFromBlockAtSize(archivist: ArchivistInstance, head: Hash, sizeIndex: number): Promise<[Lowercase<string>, number, number][]>;
-export declare function stepHashFramesFromBlock(archivist: ArchivistInstance, head: Hash): Promise<[Lowercase<string>, number, number][]>;
-//# sourceMappingURL=stepHashFramesFromBlock.d.ts.map

package/dist/types/block/primitives/frames/stepHashFramesFromBlock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stepHashFramesFromBlock.d.ts","sourceRoot":"","sources":["../../../../../src/block/primitives/frames/stepHashFramesFromBlock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAU,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAIrE,wBAAsB,6BAA6B,CAAC,SAAS,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,kDA0B9G;AAGD,wBAAsB,uBAAuB,CAAC,SAAS,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,kDAmCrF"}

package/src/block/primitives/frames/loadFrameSummaries.ts

@@ -1,12 +0,0 @@
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { BlockNumberRange } from './BlockNumberRange.ts'
-
-export async function loadFrameSummaries(
-  ranges: BlockNumberRange[],
-  finalizedArchivist: ArchivistInstance,
-  summaryArchivist: ArchivistInstance,
-): Promise<Payload[]> {
-  return await Promise.resolve([])
-}

package/src/block/primitives/frames/stepHashFramesFromBlock.ts

@@ -1,72 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { type Hash, isHash } from '@xylabs/hex'
-import { isDefined } from '@xylabs/typeof'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { isBlockBoundWitness, StepSizes } from '@xyo-network/xl1-protocol'
-
-// get the list of step frames for a block at a specific step size index
-export async function stepHashFramesFromBlockAtSize(archivist: ArchivistInstance, head: Hash, sizeIndex: number) {
-  if (!Number.isInteger(sizeIndex) || sizeIndex < 0 || sizeIndex >= StepSizes.length) {
-    throw new Error(`Invalid sizeIndex: ${sizeIndex}`)
-  }
-  let currentHead = head
-  const steps: [Hash, number, number][] = []
-  while (isHash(currentHead)) {
-    const [block] = await archivist.get([currentHead])
-    if (!isBlockBoundWitness(block)) {
-      throw new Error(`Block with hash ${currentHead} not found`)
-    }
-    let stepHash = block.step_hashes.at(sizeIndex)
-    while (isDefined(stepHash)) {
-      const [stepHashBlock] = await archivist.get([stepHash])
-      if (!isBlockBoundWitness(stepHashBlock)) {
-        throw new Error(`StepHashBlock with hash ${currentHead} not found`)
-      }
-      const [lastBlockInStep] = await archivist.get([assertEx(stepHashBlock.previous, () => 'StepHashBlock must have a previous block')])
-      if (!isBlockBoundWitness(lastBlockInStep)) {
-        throw new Error(`StepHashBlock with hash ${currentHead} not found`)
-      }
-      steps.push([stepHash, stepHashBlock.block - StepSizes[sizeIndex], stepHashBlock.block - 1])
-      stepHash = lastBlockInStep.step_hashes.at(sizeIndex)
-    }
-  }
-  return steps
-}
-
-// TODO: Figure out how to get ranges of smaller blocks for each available range
-export async function stepHashFramesFromBlock(archivist: ArchivistInstance, head: Hash) {
-  const [block] = await archivist.get([head])
-  if (!isBlockBoundWitness(block)) {
-    throw new Error(`Block with hash ${head} not found`)
-  }
-  let availableRanges: [number, number][] = [[0, block.block]]
-  const foundRanges: [Hash, number, number][] = []
-  // fit biggest to smallest
-  for (let i = StepSizes.length - 1; i >= 0; i--) {
-    const steps = await stepHashFramesFromBlockAtSize(archivist, head, i)
-    for (let step of steps) {
-      const [, start, end] = step
-      if (availableRanges.some(range => range[0] <= start && range[1] >= end)) {
-        foundRanges.push(step)
-        availableRanges = availableRanges.flatMap((range) => {
-          if (range[0] >= start && range[1] <= end) {
-            // remove the range
-            return [[range[0], start - 1]]
-          } else if (range[0] < start && range[1] >= end) {
-            // split the range
-            return [[range[0], start - 1], [end + 1, range[1]]]
-          } else if (range[0] < start && range[1] < end) {
-            // adjust the end of the range
-            return [[range[0], start - 1]]
-          } else if (range[0] > start && range[1] > end) {
-            // adjust the start of the range
-            return [[end + 1, range[1]]]
-          }
-          // otherwise, return the range as is
-          return [range]
-        })
-      }
-    }
-  }
-  return foundRanges
-}