@xyo-network/xl1-protocol-sdk 1.15.2 → 1.15.4

package/src/block/hydrate/hydrateBlock.ts

@@ -1,13 +1,34 @@
 import { assertEx } from '@xylabs/assert'
 import type { Hash } from '@xylabs/hex'
-import type { ReadArchivist } from '@xyo-network/archivist-model'
+import { isDefined } from '@xylabs/typeof'
+import { type ReadArchivist } from '@xyo-network/archivist-model'
+import type { Payload } from '@xyo-network/payload-model'
 import type { HydratedBlock } from '@xyo-network/xl1-protocol'
-import { isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
 
+import type { ChainStoreRead, PayloadMapRead } from '../../model/index.ts'
+import { isReadArchivist } from '../primitives/index.ts'
 import { allHashesPresent } from './allHashesPresent.ts'
 
+export function readPayloadMapFromStore<T extends Payload>(store: ReadArchivist<T> | PayloadMapRead<T>): PayloadMapRead<T> {
+  if (isReadArchivist(store)) {
+    return {
+      get: async (hash: Hash): Promise<T | undefined> => {
+        return (await store.get([hash]))[0]
+      },
+      getMany: async (hashes: Hash[]): Promise<T[]> => {
+        return (await store.get(hashes))
+      },
+      has: async (hash: Hash): Promise<boolean> => {
+        return isDefined((await store.get([hash]))[0])
+      },
+    }
+  }
+  return store
+}
+
 export const hydrateBlock = async (
-  archivist: ReadArchivist,
+  { chainMap }: ChainStoreRead,
   hash: Hash,
   maxDepth: number = 1,
   minDepth = maxDepth,
@@ -15,20 +36,21 @@ export const hydrateBlock = async (
   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')
-  const bw = assertEx(
-    (await archivist.get([hash])).find(isBlockBoundWitnessWithStorageMeta),
-    () => `block ${hash} not found`,
-  )
+
+  const bw = assertEx(asBlockBoundWitnessWithStorageMeta(
+    assertEx(await chainMap.get(hash), () => `block ${hash} not found`),
+  ), () => `hash ${hash} is not a BlockBoundWitness`)
+
   if (maxDepth === 0) return [bw, []]
-  const blkPayloads = await archivist.get(bw.payload_hashes)
+  const blkPayloads = await chainMap.getMany(bw.payload_hashes)
   if (minDepth === 1) assertEx(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`)
   if (maxDepth === 1) return [bw, blkPayloads]
   const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta)
   const transactionsPayloadHashes = transactions.flatMap(tx => tx.payload_hashes)
-  const transactionsPayloads = await archivist.get(transactionsPayloadHashes)
+  const transactionsPayloads = await chainMap.getMany(transactionsPayloadHashes)
   assertEx(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`)
   const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap(p => p._hash))
-  const allPayloads = await archivist.get([...allPayloadsHashes])
+  const allPayloads = await chainMap.getMany([...allPayloadsHashes])
   const allPayloadsFiltered = allPayloads.filter(p => allPayloadsHashes.has(p._hash))
   if (maxDepth === 2) assertEx(allHashesPresent(
     [...allPayloadsHashes],

package/src/block/primitives/balances/balancesStepSummaryFromRange.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-statements */
 import { assertEx } from '@xylabs/assert'
 import { type Address } from '@xylabs/hex'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
@@ -23,54 +24,60 @@ export async function balancesStepSummaryFromRange(
   // 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 head = await context.head()
 
   let result: BalancesStepSummary | undefined = undefined
 
   if (frameSize === 1) {
     const hash = await hashFromBlockNumber(context, range[0])
-    const [, payloads] = await hydrateBlock(context.chainArchivist, hash)
+    const [, payloads] = await hydrateBlock(context.store, hash)
     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,
+      schema: BalancesStepSummarySchema, hash: 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])
+    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`)
     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 => balancesStepSummaryFromRange(
-        context,
-        subRange,
-      ))
-      const subResults = await Promise.all(promises)
+      await context.stepSemaphores[step].acquire()
+      try {
+        const subRanges = deepCalculateFramesFromRange(range, step - 1)
+        const promises = subRanges.map(subRange => balancesStepSummaryFromRange(
+          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)
+        // 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)
-      }
+        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,
-      }
+        result = {
+          schema: BalancesStepSummarySchema, hash: frameHeadHash, stepSize: frameSize, balances,
+        }
 
-      await context.summaryRepository.insert([result])
+        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)}`)

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

@@ -13,8 +13,9 @@ export async function balancesSummary(
   context: BalanceStepSummaryContext,
 ): Promise<Partial<Record<Address, bigint>>> {
   return await spanRootAsync('balanceSummary', async () => {
-    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 head = await context.head()
+    const headResult = await context.store.chainMap.get(head)
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `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 => balancesStepSummaryFromRange(context, range)))

package/src/block/primitives/blockFromBlockNumber.ts

@@ -4,11 +4,12 @@ import type { WithStorageMeta } from '@xyo-network/payload-model'
 import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
 import { asBlockBoundWitnessWithStorageMeta, StepSizes } from '@xyo-network/xl1-protocol'
 
-import type { ChainContext } from './model.ts'
+import type { ChainContextRead } from '../../model/index.ts'
 
-export async function blockFromBlockNumber(context: ChainContext, blockNumber: number): Promise<WithStorageMeta<BlockBoundWitness>> {
-  const result = await context.chainArchivist.get([context.head])
-  let currentBlock = asBlockBoundWitnessWithStorageMeta(result.at(0), () => `Head block not found for hash: ${context.head}`, { required: true })
+export async function blockFromBlockNumber(context: ChainContextRead, blockNumber: number): Promise<WithStorageMeta<BlockBoundWitness>> {
+  const head = await context.head()
+  const result = await context.store.chainMap.get(head)
+  let currentBlock = asBlockBoundWitnessWithStorageMeta(result, () => `Head block not found for hash: ${head}`, { required: true })
   while (currentBlock.block > blockNumber) {
     let jumpHash: Hash | null = currentBlock.previous
     let jumpBlockNumber = currentBlock.block - 1
@@ -19,8 +20,9 @@ export async function blockFromBlockNumber(context: ChainContext, blockNumber: n
         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} ${toSafeJsonString(currentBlock, 10)}`)])
+    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 (currentBlock.block === blockNumber) {
       break

package/src/block/primitives/hashFromBlockNumber.ts

@@ -1,8 +1,8 @@
 import { type Hash } from '@xylabs/hex'
 
+import type { ChainContextRead } from '../../model/index.ts'
 import { blockFromBlockNumber } from './blockFromBlockNumber.ts'
-import type { ChainContext } from './model.ts'
 
-export async function hashFromBlockNumber(context: ChainContext, blockNumber: number): Promise<Hash> {
+export async function hashFromBlockNumber(context: ChainContextRead, blockNumber: number): Promise<Hash> {
   return (await blockFromBlockNumber(context, blockNumber))._hash
 }

package/src/block/primitives/model.ts

@@ -1,23 +1,27 @@
-import type { Address, 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 { Semaphore } from 'async-mutex'
 
+import type { MapTypeRead, MapTypeWrite } from '../../map/index.ts'
+import type { ChainContextRead } from '../../model/index.ts'
 import type { BalancesStepSummary, TransfersStepSummary } from './payloads/index.ts'
 
-export interface ChainContext {
-  chainArchivist: ReadArchivist
-  head: Hash
+export function isReadArchivist(obj: unknown): obj is ReadArchivist {
+  return (obj as ReadArchivist).get !== undefined && (obj as ReadArchivist).next !== undefined
+}
+
+export interface ChainSummaryContextRead<T extends Payload> extends ChainContextRead {
+  stepSemaphores: Semaphore[]
+  summaryMap: MapTypeRead<string, T>
   windowSize?: number
 }
 
-export interface ChainSummaryContext<T extends Payload> extends ChainContext {
-  summaryRepository: PayloadRepository<Hash, T>
+export interface ChainSummaryContextWrite<T extends Payload> extends ChainContextRead {
+  summaryMap: MapTypeWrite<string, T>
 }
 
+export type ChainSummaryContext<T extends Payload> = ChainSummaryContextRead<T> & ChainSummaryContextWrite<T>
+
 export interface BalanceStepSummaryContext extends ChainSummaryContext<BalancesStepSummary> {}
 
-export interface TransfersStepSummaryContext extends ChainSummaryContext<TransfersStepSummary> {
-  /* The address that the transfers to/from are being summarized */
-  account: Address
-}
+export interface TransfersStepSummaryContext extends ChainSummaryContext<TransfersStepSummary> {}

package/src/block/primitives/payloads/StepSummary.ts

@@ -12,4 +12,4 @@ export interface StepSummaryFields {
 
 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>
+  TSchema extends void ? StepSummarySchema : TSchema>

package/src/block/primitives/payloads/TransfersSummary.ts

@@ -10,8 +10,7 @@ export const TransfersStepSummarySchema: Schema = 'network.xyo.step.summary.tran
 export type TransfersStepSummarySchema = typeof TransfersStepSummarySchema
 
 export type TransfersStepSummary = StepSummary<{
-  account: Address
-  transfers: Record<Address, SignedBigInt>
+  transfers: Record<Address, Record<Address, SignedBigInt>>
 }, TransfersStepSummarySchema>
 
 /**

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

@@ -1,3 +1,4 @@
+/* eslint-disable max-statements */
 import { assertEx } from '@xylabs/assert'
 import { type Address } from '@xylabs/hex'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
@@ -22,55 +23,69 @@ export async function transfersStepSummaryFromRange(
   // console.log(`transfersStepSummaryFromRange: head=${head}, range=${range[0]}-${range[1]}`)
   const frameHeadHash = await hashFromBlockNumber(context, range[1])
   const frameSize = range[1] - range[0] + 1
-  const { account } = context
+  const head = await context.head()
 
   let result: TransfersStepSummary | undefined = undefined
 
   if (frameSize === 1) {
     const hash = await hashFromBlockNumber(context, range[0])
-    const [, payloads] = await hydrateBlock(context.chainArchivist, hash)
-    const transfers: Record<Address, SignedBigInt> = {}
-    for (const [address, balance] of Object.entries(netTransfersForPayloads(payloads, account))) {
-      transfers[address as Address] = toSignedBigInt(balance)
+    const [, payloads] = await hydrateBlock(context.store, hash)
+    const transfers: Record<Address, Record<Address, SignedBigInt>> = {}
+    for (const [from, toMap] of Object.entries(netTransfersForPayloads(payloads))) {
+      transfers[from as Address] = transfers[from as Address] ?? {}
+      for (const [to, amount] of Object.entries(toMap)) {
+        transfers[from as Address][to as Address] = toSignedBigInt(amount)
+      }
     }
     result = {
-      schema: TransfersStepSummarySchema, hash: context.head, stepSize: -1, transfers, account,
+      schema: TransfersStepSummarySchema, hash: head, stepSize: -1, transfers,
     }
   } 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])
+    const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`)
     if (isAnyPayload(summaryResult)) {
       result = summaryResult as WithStorageMeta<TransfersStepSummary>
     } else {
-    // We do not have it, so lets build it
-      const subRanges = deepCalculateFramesFromRange(range, step - 1)
-      const promises = subRanges.map(subRange => transfersStepSummaryFromRange(
-        context,
-        subRange,
-      ))
-      const subResults = await Promise.all(promises)
+      await context.stepSemaphores[step].acquire()
+      // We do not have it, so lets build it
+      try {
+        const subRanges = deepCalculateFramesFromRange(range, step - 1)
+        const promises = subRanges.map(subRange => transfersStepSummaryFromRange(
+          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, transfer] of Object.entries(subResult.transfers)) {
-          bigIntBalances[address as Address] = (bigIntBalances[address as Address] ?? 0n) + parseSignedBigInt(transfer)
+        // add them all up
+        const bigIntBalances: Record<Address, Record<Address, bigint>> = {}
+        for (const subResult of subResults) {
+          for (const [from, toMap] of Object.entries(subResult.transfers)) {
+            bigIntBalances[from as Address] = bigIntBalances[from as Address] ?? {}
+            for (const [to, transfer] of Object.entries(toMap)) {
+              bigIntBalances[from as Address][to as Address] = (bigIntBalances[from as Address][to as Address] ?? 0n) + parseSignedBigInt(transfer)
+            }
+          }
         }
-      }
 
-      const transfers: Record<Address, SignedBigInt> = {}
-      for (const [address, transfer] of Object.entries(bigIntBalances)) {
-        transfers[address as Address] = toSignedBigInt(transfer)
-      }
+        const transfers: Record<Address, Record<Address, SignedBigInt>> = {}
+        for (const [from, toMap] of Object.entries(bigIntBalances)) {
+          transfers[from as Address] = transfers[from as Address] ?? {}
+          for (const [to, transfer] of Object.entries(toMap)) {
+            transfers[from as Address][to as Address] = toSignedBigInt(transfer)
+          }
+        }
 
-      result = {
-        schema: TransfersStepSummarySchema, hash: frameHeadHash, stepSize: frameSize, transfers, account,
-      }
+        result = {
+          schema: TransfersStepSummarySchema, hash: frameHeadHash, stepSize: frameSize, transfers,
+        }
 
-      await context.summaryRepository.insert([result])
+        await context.summaryMap.set(`${frameHeadHash}|${frameSize}`, result)
+      } finally {
+        context.stepSemaphores[step].release()
+      }
     }
   }
   // console.log(`transfersStepSummaryFromRange-result: head=${head}, range=${range[0]}-${range[1]}: ${toSafeJsonString(result, 10)}`)

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

@@ -12,18 +12,23 @@ 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,
-): Promise<Partial<Record<Address, bigint>>> {
+): Promise<Partial<Record<Address, Partial<Record<Address, bigint>>>>> {
   return await spanRootAsync('transferSummary', async () => {
-    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 head = await context.head()
+    const headResult = await context.store.chainMap.get(head)
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `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 => transfersStepSummaryFromRange(context, range)))
-    const transfers: Partial<Record<Address, bigint>> = {}
+    const transfers: Partial<Record<Address, Partial<Record<Address, bigint>>>> = {}
     for (let summary of summaries) {
-      for (const [address, transfer] of Object.entries(summary.transfers)) {
-        const validAddress = asAddress(address, () => `Invalid address: ${address}`)
-        transfers[validAddress] = (transfers[validAddress] ?? 0n) + parseSignedBigInt(transfer)
+      for (const [from, toMap] of Object.entries(summary.transfers)) {
+        const validFrom = asAddress(from, () => `Invalid address: ${from}`)
+        transfers[validFrom] = transfers[validFrom] ?? {}
+        for (const [to, transfer] of Object.entries(toMap)) {
+          const validTo = asAddress(to, () => `Invalid address: ${to}`)
+          transfers[validFrom][validTo] = (transfers[validFrom][validTo] ?? 0n) + parseSignedBigInt(transfer)
+        }
       }
     }
     return transfers

package/src/config/Bridge.ts

@@ -0,0 +1,26 @@
+import { globalRegistry } from 'zod'
+import * as z from 'zod'
+
+import { MnemonicStringZod } from '../validation/index.ts'
+
+export const BridgeConfigZod = z.object({
+  host: z.string().default('localhost').register(globalRegistry, {
+    default: 'localhost',
+    description: 'Host for the Bridge',
+    title: 'api.host',
+    type: 'string',
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
+    description: 'Mnemonic for the Bridge wallet',
+    title: 'api.mnemonic',
+    type: 'string',
+  }),
+  port: z.coerce.number().default(8081).register(globalRegistry, {
+    default: 8081,
+    description: 'Port for the Bridge',
+    title: 'api.port',
+    type: 'number',
+  }),
+})
+
+export type BridgeConfig = z.infer<typeof BridgeConfigZod>

package/src/config/Config.ts

@@ -2,6 +2,7 @@ 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'
 import { LogConfigZod } from './Log.ts'
@@ -15,6 +16,7 @@ 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'),
   producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe('Configuration for the producer'),

package/src/index.ts

@@ -3,6 +3,8 @@ export * from './ChainServiceCollection.ts'
 export * from './ChainServiceCollectionV2.ts'
 export * from './config/index.ts'
 export * from './instances/index.ts'
+export * from './map/index.ts'
+export * from './model/index.ts'
 export * from './payload/index.ts'
 export * from './SignedBigInt.ts'
 export * from './steps/index.ts'

package/src/instances/ShiftedBigIntConfig.ts

@@ -1,4 +1,4 @@
-/** @deprecated use from @xyo-network/xl1-protocol instead */
+/** @deprecated use from \@xyo-network/xl1-protocol instead */
 export interface ShiftedBigIntConfig {
   locale: Intl.LocalesArgument
   maxCharacters: number

package/src/instances/XL1Amount.ts

@@ -7,7 +7,7 @@ import type {
 
 import type { ShiftedBigIntConfig } from './ShiftedBigIntConfig.ts'
 
-/** @deprecated use from @xyo-network/xl1-protocol instead */
+/** @deprecated use from \@xyo-network/xl1-protocol instead */
 export interface XL1AmountInstance {
   value: AttoXL1
 

package/src/map/AsynchronousMap.ts

@@ -0,0 +1,15 @@
+import type { Promisable } from '@xylabs/promise'
+
+export interface AsynchronousMapRead<K, V> {
+  get(id: K): Promisable<V | undefined>
+  getMany(id: K[]): Promisable<V[]>
+  has(id: K): Promisable<boolean>
+}
+
+export interface AsynchronousMapWrite<K, V> {
+  clear(): Promisable<void>
+  delete(id: K): Promisable<boolean>
+  set(id: K, data: V): Promisable<void>
+}
+
+export interface AsynchronousMap<K, V> extends AsynchronousMapRead<K, V>, AsynchronousMapWrite<K, V> {}

package/src/map/MapType.ts

@@ -0,0 +1,8 @@
+import type { AsynchronousMapRead, AsynchronousMapWrite } from './AsynchronousMap.ts'
+import type { SynchronousMapRead, SynchronousMapWrite } from './SynchronousMap.ts'
+
+export type MapTypeWrite<TId, TData> = SynchronousMapWrite<TId, TData> | AsynchronousMapWrite<TId, TData>
+
+export type MapTypeRead<TId, TData> = SynchronousMapRead<TId, TData> | AsynchronousMapRead<TId, TData>
+
+export type MapType<TId, TData> = MapTypeRead<TId, TData> & MapTypeWrite<TId, TData>

package/src/map/SynchronousMap.ts

@@ -0,0 +1,13 @@
+export interface SynchronousMapRead<K, V> {
+  get(id: K): V | undefined
+  getMany(id: K[]): V[]
+  has(id: K): boolean
+}
+
+export interface SynchronousMapWrite<K, V> {
+  clear(): void
+  delete(id: K): boolean
+  set(id: K, data: V): void
+}
+
+export interface SynchronousMap<K, V> extends SynchronousMapRead<K, V>, SynchronousMapWrite<K, V> {}

package/src/map/index.ts

@@ -0,0 +1,3 @@
+export * from './AsynchronousMap.ts'
+export * from './MapType.ts'
+export * from './SynchronousMap.ts'

package/src/model/ChainContext/ChainContext.ts

@@ -0,0 +1,20 @@
+import type { ChainIdentity } from '../ChainIdentity.ts'
+import type {
+  ChainStakeContext, ChainStakeContextRead, ChainStakeContextWrite,
+} from './ChainStakeContext.ts'
+import type { ChainStateContextRead, ChainStateContextWrite } from './ChainStateContext.ts'
+import type {
+  ChainStoreContext, ChainStoreContextRead, ChainStoreContextWrite,
+} from './ChainStoreContext.ts'
+
+export interface ChainContextWrite extends ChainIdentity, ChainStateContextWrite, ChainStoreContextWrite {}
+
+export interface StakedChainContextWrite extends ChainContextWrite, ChainStakeContextWrite {}
+
+export interface ChainContextRead extends ChainIdentity, ChainStateContextRead, ChainStoreContextRead {}
+
+export interface StakedChainContextRead extends ChainContextRead, ChainStakeContextRead {}
+
+export type ChainContext = ChainIdentity & ChainContextRead & ChainContextWrite & ChainStoreContext
+
+export type StakedChainContext = ChainContext & ChainStakeContext & ChainStakeContextRead & ChainStakeContextWrite

package/src/model/ChainContext/ChainStakeContext.ts

@@ -0,0 +1,12 @@
+import type { ChainIdentity } from '../ChainIdentity.ts'
+import type { ChainStakeRead, ChainStakeWrite } from '../ChainStake/index.ts'
+
+export interface ChainStakeContextWrite extends ChainIdentity {
+  stake: ChainStakeWrite
+}
+
+export interface ChainStakeContextRead extends ChainIdentity {
+  stake: ChainStakeRead
+}
+
+export type ChainStakeContext = ChainStakeContextRead & ChainStakeContextWrite

package/src/model/ChainContext/ChainStateContext.ts

@@ -0,0 +1,10 @@
+import type { Hash } from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
+
+export interface ChainStateContextRead {
+  head(): Promisable<Hash>
+}
+
+export interface ChainStateContextWrite {}
+
+export type ChainStateContext = ChainStateContextRead & ChainStateContextWrite

package/src/model/ChainContext/ChainStoreContext.ts

@@ -0,0 +1,12 @@
+import type { ChainIdentity } from '../ChainIdentity.ts'
+import type { ChainStoreRead, ChainStoreWrite } from '../ChainStore.ts'
+
+export interface ChainStoreContextWrite extends ChainIdentity {
+  store: ChainStoreWrite
+}
+
+export interface ChainStoreContextRead extends ChainIdentity {
+  store: ChainStoreRead
+}
+
+export type ChainStoreContext = ChainStoreContextRead & ChainStoreContextWrite

package/src/model/ChainContext/index.ts

@@ -0,0 +1,4 @@
+export * from './ChainContext.ts'
+export * from './ChainStakeContext.ts'
+export * from './ChainStateContext.ts'
+export * from './ChainStoreContext.ts'

package/src/model/ChainFork/ChainForkStatic.ts

@@ -0,0 +1,8 @@
+import type { Hash } from '@xylabs/hex'
+import type { ChainId } from '@xyo-network/xl1-protocol'
+
+export interface ChainForkStatic {
+  forkedAtBlockNumber: number
+  forkedAtHash: Hash
+  forkedChainId: ChainId
+}

package/src/model/ChainFork/index.ts

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

package/src/model/ChainIdentity.ts

@@ -0,0 +1,5 @@
+import type { ChainId } from '@xyo-network/xl1-protocol'
+
+export interface ChainIdentity {
+  chainId: ChainId
+}

package/src/model/ChainStake/ChainStakeRead.ts

@@ -0,0 +1,17 @@
+import type { Address } from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
+import type { Stake } from '@xyo-network/xl1-protocol'
+
+export interface ChainStakeRead {
+  active(): Promisable<bigint>
+  activeByAddressStaked(address: string): Promisable<bigint>
+  activeByStaker(address: string): Promisable<bigint>
+  pending(): Promisable<bigint>
+  pendingByStaker(staker: string): Promisable<bigint>
+  stakeById(id: number): Promisable<Stake>
+  stakeByStaker(staker: Address, slot: number): Promisable<Stake>
+  stakesByStaked(staked: Address, range?: [number, number | 'latest']): Promisable<Stake[]>
+  stakesByStaker(staker: Address, range?: [number, number | 'latest']): Promisable<Stake[]>
+  withdrawn(): Promisable<bigint>
+  withdrawnByStaker(staker: string): Promisable<bigint>
+}