@xyo-network/xl1-protocol-lib 1.26.1

package/src/network/Status.ts

@@ -0,0 +1,30 @@
+import type { Payload } from '@xyo-network/sdk-js'
+import { asSchema, isPayloadOfSchemaType } from '@xyo-network/sdk-js'
+
+/** Schema identifier for network status payloads. */
+export const NetworkStatusSchema = asSchema('network.xyo.chain.status', true)
+/** Schema type for NetworkStatus payloads. */
+export type NetworkStatusSchema = typeof NetworkStatusSchema
+
+/** Possible states of the network: online, offline, degraded, or unknown. */
+export type NetworkStatusState = 'online' | 'offline' | 'degraded' | 'unknown'
+
+/** Represents a single network status update with a time range and description. */
+export type NetworkStatusUpdate = {
+  end: number
+  start: number
+  update: string
+}
+
+/** Fields describing the current network status, including state and optional updates. */
+export interface NetworkStatusFields {
+  description: string
+  state: NetworkStatusState
+  updates?: NetworkStatusUpdate[]
+}
+
+/** A payload representing the current network status. */
+export type NetworkStatus = Payload<NetworkStatusFields, NetworkStatusSchema>
+
+/** Type guard that checks whether a value is a NetworkStatus payload. */
+export const isNetworkStatus = isPayloadOfSchemaType<NetworkStatus>(NetworkStatusSchema)

package/src/network/index.ts

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

package/src/permissions/InvokerPermission.ts

@@ -0,0 +1,58 @@
+import type { JsonValue } from '@xylabs/sdk-js'
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ *
+ * In order to send multiple permission requests at once, do not send multiple parentCapability keys.
+ * Instead, send multiple PermissionRequest objects in the params array of the rpc call.
+ */
+export interface PermissionRequest {
+  [parentCapability: string]: {
+    [caveatName: string]: JsonValue
+  }
+}
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+export interface RequestedPermission {
+  /** Optional timestamp for when the permission was granted */
+  date?: number
+  /** Permission identifier (i.e. RPC method, action, etc.) */
+  parentCapability: string
+}
+
+/** CaveatTypes type. */
+export type CaveatTypes = 'chain' | 'expiration' | 'filteredResponse' | 'rateLimit' | 'restrictReturnedAccounts'
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+export interface Caveats {
+  /** Type of caveat */
+  type: CaveatTypes
+  /** Value for the caveat (i.e. chain id, subset of accounts, expiration, max request per minute, etc.) */
+  value: JsonValue
+}
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+export interface Permission {
+  /** Caveats for the permission, if applicable (i.e. allowed accounts, signing, etc.) */
+  caveats?: Caveats[]
+  /** Invoker for the given permission (URI, domain, webpage, address, etc.) */
+  invoker: string
+  /** Permission identifier (i.e. RPC method, action, etc.) */
+  parentCapability: string
+}
+
+/** InvokerPermission interface. */
+export interface InvokerPermission extends Permission {
+  /** Time at which the permission was granted */
+  date?: number
+}

package/src/permissions/XyoPermissions.ts

@@ -0,0 +1,41 @@
+import type {
+  InvokerPermission, PermissionRequest, RequestedPermission,
+} from './InvokerPermission.ts'
+
+/**
+ * Handles Getting Permissions
+ */
+export interface PermissionsGetHandler {
+  /**
+   * Returns the permissions that are currently granted
+   *
+   * Per the spec - "The wallet_getPermissions method is used for getting an array of current permissions
+   * (empty by default). It takes no parameters and returns an array of Permission objects."
+   *
+   * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+   */
+  getPermissions(): Promise<InvokerPermission[]>
+}
+
+/**
+ * Handles Permission Requests
+ */
+export interface PermissionRequestsHandler {
+  // Given a permissions request, attempts to request the permissions from the user
+  requestPermissions(permissions: PermissionRequest[]): Promise<RequestedPermission[]>
+  // Given a permissions request, attempts to revoke the permissions from the user
+  revokePermissions(permissions: PermissionRequest): Promise<RequestedPermission[]>
+}
+
+/**
+ * Interface for getting, requesting and revoking permissions
+ *
+ * See - https://eips.ethereum.org/EIPS/eip-2255
+ */
+export interface XyoPermissions extends PermissionsGetHandler, PermissionRequestsHandler {
+
+}
+
+// @deprecated - use XyoPermissions instead
+/** PermissionsProvider interface. */
+export interface PermissionsProvider extends XyoPermissions {}

package/src/permissions/index.ts

@@ -0,0 +1,2 @@
+export * from './InvokerPermission.ts'
+export * from './XyoPermissions.ts'

package/src/providers/DataLake/Provider.ts

@@ -0,0 +1,11 @@
+import type { Payload, Schema } from '@xyo-network/sdk-js'
+import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-model'
+
+/** DataLakeData type. */
+export type DataLakeData = Payload | ArrayBuffer
+
+/** DataLakeProvider interface. */
+export interface DataLakeProvider<TMoniker extends ProviderMoniker = ProviderMoniker> extends Provider<TMoniker> {
+  allowedSchemas?: Schema[]
+  disallowedSchemas?: Schema[]
+}

package/src/providers/DataLake/Runner.ts

@@ -0,0 +1,16 @@
+import type { Hash } from '@xylabs/sdk-js'
+import type { WriteArchivistFunctions } from '@xyo-network/sdk-js'
+
+import type { DataLakeData, DataLakeProvider } from './Provider.ts'
+import type { DataLakeViewer, DataLakeViewerMethods } from './Viewer.ts'
+
+/** Moniker identifier for the DataLakeRunner provider. */
+export const DataLakeRunnerMoniker = 'DataLakeRunner' as const
+/** Type literal for the DataLakeRunner provider moniker. */
+export type DataLakeRunnerMoniker = typeof DataLakeRunnerMoniker
+
+/** DataLakeRunnerMethods interface. */
+export interface DataLakeRunnerMethods extends WriteArchivistFunctions<DataLakeData, DataLakeData, DataLakeData, Hash>, DataLakeViewerMethods {}
+
+/** Runner interface for executing DataLake operations. */
+export interface DataLakeRunner extends DataLakeProvider<DataLakeRunnerMoniker>, DataLakeRunnerMethods, Omit<DataLakeViewer, 'moniker'> {}

package/src/providers/DataLake/Viewer.ts

@@ -0,0 +1,16 @@
+import type { Hash } from '@xylabs/sdk-js'
+import type { ReadArchivistFunctions, Sequence } from '@xyo-network/sdk-js'
+
+import type { DataLakeData, DataLakeProvider } from './Provider.ts'
+
+/** Moniker identifier for the DataLakeViewer provider. */
+export const DataLakeViewerMoniker = 'DataLakeViewer' as const
+/** Type literal for the DataLakeViewer provider moniker. */
+export type DataLakeViewerMoniker = typeof DataLakeViewerMoniker
+
+/** DataLakeViewerMethods interface. */
+export interface DataLakeViewerMethods extends ReadArchivistFunctions<DataLakeData, Hash, Sequence> {}
+
+/** Viewer interface for reading DataLake data. */
+export interface DataLakeViewer extends DataLakeProvider<DataLakeViewerMoniker>, DataLakeViewerMethods {
+}

package/src/providers/DataLake/index.ts

@@ -0,0 +1,3 @@
+export * from './Provider.ts'
+export * from './Runner.ts'
+export * from './Viewer.ts'

package/src/providers/TransactionHelper.ts

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/member-ordering */
+import type { Payload } from '@xyo-network/sdk-js'
+import type { UnsignedHydratedTransaction } from '@xyo-network/xl1-protocol-model'
+
+/** TransactionHelper interface. */
+export interface TransactionHelper {
+  // build tx, sign tx, send tx
+  addPayloadsToChain(onChain: Payload[], offChain: Payload[]): void
+
+  // sign tx, send tx
+  addUnsignedTransactionToChain(tx: UnsignedHydratedTransaction): void
+
+  // send tx (primitive)
+  addSignedTransactionToChain(tx: UnsignedHydratedTransaction): void
+}

package/src/providers/XyoClient.ts

@@ -0,0 +1,27 @@
+import type { GatewayName } from '@xyo-network/xl1-protocol-model'
+
+import type { XyoPermissions } from '../permissions/index.ts'
+import type { XyoGateway } from './XyoGateway.ts'
+import type { XyoGatewayRunner } from './XyoGatewayRunner.ts'
+
+/** @deprecated */
+export interface XyoGatewayConfig {
+  name: GatewayName
+}
+
+/** @deprecated */
+export interface XyoRpcGatewayConfig extends XyoGatewayConfig {
+  dataLakeEndpoint: string
+  networkEndpoint: string
+}
+
+/** XyoClient interface. */
+export interface XyoClient {
+  gateways: Readonly<Partial<Record<GatewayName, XyoGatewayRunner>>>
+  permissions: XyoPermissions
+
+  /** @deprecated */
+  addGateway?(providerOrConfig: XyoGatewayConfig | XyoRpcGatewayConfig | XyoGateway): Promise<XyoGateway>
+  /** @deprecated */
+  removeGateway?(name: GatewayName): Promise<void>
+}

package/src/providers/XyoConnection.ts

@@ -0,0 +1,20 @@
+import type { Provider } from '@xyo-network/xl1-protocol-model'
+
+import type { NetworkStakeViewer, XyoViewer } from '../viewers/index.ts'
+import type { DataLakeRunner, DataLakeViewer } from './DataLake/index.ts'
+import type { XyoNetwork } from './XyoNetwork.ts'
+import type { XyoRunner } from './XyoRunner.ts'
+
+/** Moniker identifier for the XyoConnection provider. */
+export const XyoConnectionMoniker = 'XyoConnection' as const
+/** Type literal for the XyoConnection provider moniker. */
+export type XyoConnectionMoniker = typeof XyoConnectionMoniker
+
+/** XyoConnection interface. */
+export interface XyoConnection extends Provider<XyoConnectionMoniker> {
+  network?: XyoNetwork
+  networkStake?: NetworkStakeViewer
+  runner?: XyoRunner
+  storage?: DataLakeRunner | DataLakeViewer | (DataLakeRunner & DataLakeViewer)
+  viewer?: XyoViewer
+}

package/src/providers/XyoGateway.ts

@@ -0,0 +1,24 @@
+import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-model'
+
+import type { XyoConnection } from './XyoConnection.ts'
+
+/** Moniker identifier for the XyoGateway provider. */
+export const XyoGatewayMoniker = 'XyoGateway' as const
+/** Type literal for the XyoGateway provider moniker. */
+export type XyoGatewayMoniker = typeof XyoGatewayMoniker
+
+/** XyoGatewayMethods interface. */
+export interface XyoGatewayMethods {}
+
+/** XyoGatewayProvider interface. */
+export interface XyoGatewayProvider<
+  TMoniker extends ProviderMoniker = ProviderMoniker> extends XyoGatewayMethods, Provider<TMoniker> {
+  /**
+   * Returns the connection provider for this gateway.
+   */
+  connection: XyoConnection
+}
+
+/** XyoGateway interface. */
+export interface XyoGateway extends XyoGatewayProvider<XyoGatewayMoniker>, Provider<XyoGatewayMoniker> {
+}

package/src/providers/XyoGatewayRunner.ts

@@ -0,0 +1,72 @@
+import type {
+  Address, Hash, Logger, Promisable,
+} from '@xylabs/sdk-js'
+import type { Payload } from '@xyo-network/sdk-js'
+import type {
+  AllowedBlockPayload, AttoXL1, ChainId,
+  SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta,
+  TransactionFeesBigInt, UnsignedHydratedTransaction, XL1BlockNumber,
+} from '@xyo-network/xl1-protocol-model'
+
+import type { XyoSigner } from './signer/index.ts'
+import type { XyoGatewayProvider } from './XyoGateway.ts'
+
+/** ConfirmSubmittedTransactionOptions type. */
+export type ConfirmSubmittedTransactionOptions = {
+  /**
+   * Number of attempts to confirm the transaction.
+   * Defaults to 20.
+   */
+  attempts?: number
+  /**
+   * Delay in milliseconds between confirmation attempts.
+   * Defaults to 1000 (1 second).
+   */
+  delay?: number
+  /**
+   * Optional logger instance for logging progress.
+   */
+  logger?: Logger
+}
+
+/** Options for Transaction. */
+export interface TransactionOptions {
+  chain?: ChainId
+  exp?: XL1BlockNumber
+  fees?: TransactionFeesBigInt
+  from?: Address
+  nbf?: XL1BlockNumber
+}
+
+/** Moniker identifier for the XyoGatewayRunner provider. */
+export const XyoGatewayRunnerMoniker = 'XyoGatewayRunner' as const
+/** Type literal for the XyoGatewayRunner provider moniker. */
+export type XyoGatewayRunnerMoniker = typeof XyoGatewayRunnerMoniker
+
+/** XyoGatewayRunnerMethods interface. */
+export interface XyoGatewayRunnerMethods {
+
+  addPayloadsToChain(
+    onChain: AllowedBlockPayload[],
+    offChain: Payload[],
+    options?: TransactionOptions
+  ): Promisable<[Hash, SignedHydratedTransactionWithHashMeta]>
+
+  addTransactionToChain(
+    tx: UnsignedHydratedTransaction | SignedHydratedTransaction,
+    offChain?: Payload[]
+  ): Promisable<[Hash, SignedHydratedTransactionWithHashMeta]>
+
+  confirmSubmittedTransaction(txHash: Hash, options?: ConfirmSubmittedTransactionOptions): Promisable<SignedHydratedTransaction>
+
+  send(to: Address, amount: AttoXL1, options?: TransactionOptions): Promisable<Hash>
+  sendMany(transfers: Record<Address, AttoXL1>, options?: TransactionOptions): Promisable<Hash>
+}
+
+/** Runner interface for executing XyoGateway operations. */
+export interface XyoGatewayRunner extends XyoGatewayRunnerMethods, XyoGatewayProvider<XyoGatewayRunnerMoniker> {
+  /**
+   * Returns the signer for this gateway.
+   */
+  signer: XyoSigner
+}

package/src/providers/XyoNetwork.ts

@@ -0,0 +1,8 @@
+import type { Promisable } from '@xylabs/sdk-js'
+
+import type { NetworkStatus } from '../network/index.ts'
+
+/** XyoNetwork interface. */
+export interface XyoNetwork {
+  status(): Promisable<NetworkStatus>
+}

package/src/providers/XyoRunner.ts

@@ -0,0 +1,19 @@
+import type { Hash, Promisable } from '@xylabs/sdk-js'
+import type { Provider, SignedHydratedTransaction } from '@xyo-network/xl1-protocol-model'
+
+import type { MempoolRunner } from '../runners/index.ts'
+
+/** XyoRunnerMethods interface. */
+export interface XyoRunnerMethods {
+  broadcastTransaction(transaction: SignedHydratedTransaction): Promisable<Hash>
+}
+
+/** Moniker identifier for the XyoRunner provider. */
+export const XyoRunnerMoniker = 'XyoRunner' as const
+/** Type literal for the XyoRunner provider moniker. */
+export type XyoRunnerMoniker = typeof XyoRunnerMoniker
+
+/** Runner interface for executing Xyo operations. */
+export interface XyoRunner extends XyoRunnerMethods, Provider<XyoRunnerMoniker> {
+  mempool: MempoolRunner
+}

package/src/providers/index.ts

@@ -0,0 +1,8 @@
+export * from './DataLake/index.ts'
+export * from './signer/index.ts'
+export * from './XyoClient.ts'
+export * from './XyoConnection.ts'
+export * from './XyoGateway.ts'
+export * from './XyoGatewayRunner.ts'
+export * from './XyoNetwork.ts'
+export * from './XyoRunner.ts'

package/src/providers/signer/XyoSigner.ts

@@ -0,0 +1,36 @@
+import type { Address, Promisable } from '@xylabs/sdk-js'
+import type { Payload, Signed } from '@xyo-network/sdk-js'
+import type {
+  AllowedBlockPayload, ChainId, Provider, SignedHydratedTransactionWithHashMeta, TransactionBoundWitness, TransactionFeesBigInt,
+} from '@xyo-network/xl1-protocol-model'
+
+/** Moniker identifier for the XyoSigner provider. */
+export const XyoSignerMoniker = 'XyoSigner' as const
+/** Type literal for the XyoSigner provider moniker. */
+export type XyoSignerMoniker = typeof XyoSignerMoniker
+
+/** XyoSignerMethods interface. */
+export interface XyoSignerMethods {
+  address(): Promisable<Address>
+  // The tx passed in must have all the payloads (on and off chain) in the payloads array
+  // Returns the signed transaction and the payloads array excluding the off-chain payloads.
+  // The return value is ready to be broadcast to block producers
+  signTransaction(tx: [TransactionBoundWitness, Payload[]]): Promisable<SignedHydratedTransactionWithHashMeta>
+}
+
+/** XyoSigner interface. */
+export interface XyoSigner extends XyoSignerMethods, Provider<XyoSignerMoniker> {}
+
+/** XyoSignerDeprecated interface. */
+export interface XyoSignerDeprecated {
+  /** @deprecated use signTransaction instead */
+  createSignedTransaction(
+    chain: ChainId,
+    elevatedPayloads: AllowedBlockPayload[],
+    additionalPayloads: Payload[],
+    nbf: number,
+    exp: number,
+    fees: TransactionFeesBigInt,
+    from?: Address,
+  ): Promisable<Signed<TransactionBoundWitness>>
+}

package/src/providers/signer/index.ts

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

package/src/repository/Repository.ts

@@ -0,0 +1,32 @@
+import type { Hash, Promisable } from '@xylabs/sdk-js'
+import type {
+  NextOptions, Payload, WithStorageMeta,
+} from '@xyo-network/sdk-js'
+
+/** ReadRepository interface. */
+export interface ReadRepository<TId, TData> {
+  get(id: TId): Promisable<TData>
+}
+
+/** IterableRepository interface. */
+export interface IterableRepository<TId, TData> {
+  next(id: TId): Promisable<TData>
+}
+
+/** WriteRepository interface. */
+export interface WriteRepository<TData, TResp> {
+  insert(data: TData): Promisable<TResp>
+}
+
+/** PayloadReadRepository interface. */
+export interface PayloadReadRepository<TId = Hash, TData extends Payload = Payload> extends ReadRepository<TId[], WithStorageMeta<TData>[]> {}
+/** PayloadWriteRepository interface. */
+export interface PayloadWriteRepository<TData extends Payload = Payload> extends WriteRepository<TData[], WithStorageMeta<TData>[]> {}
+
+/** PayloadIterableRepository interface. */
+export interface PayloadIterableRepository<TId = Hash, TData extends Payload = Payload>
+  extends IterableRepository<NextOptions<TId>, WithStorageMeta<TData>[]> {}
+
+/** PayloadRepository interface. */
+export interface PayloadRepository<TId = Hash, TData extends Payload = Payload>
+  extends PayloadReadRepository<TId, TData>, PayloadWriteRepository<TData>, PayloadIterableRepository<TId, TData> {}

package/src/repository/TransactionReadRepository.ts

@@ -0,0 +1,6 @@
+import type { SignedHydratedTransaction, TransactionBoundWitness } from '@xyo-network/xl1-protocol-model'
+
+import type { ReadRepository } from './Repository.ts'
+
+/** TransactionReadRepository interface. */
+export interface TransactionReadRepository extends ReadRepository<TransactionBoundWitness, SignedHydratedTransaction | undefined> {}

package/src/repository/TransactionRepository.ts

@@ -0,0 +1,12 @@
+import type { TransactionReadRepository } from './TransactionReadRepository.ts'
+import type { TransactionRepositoryIterator } from './TransactionRepositoryIterator.ts'
+import type { TransactionWriteRepository } from './TransactionWriteRepository.ts'
+
+/** TransactionRepository interface. */
+export interface TransactionRepository extends TransactionReadRepository, TransactionWriteRepository {}
+
+/** ReadonlyIterableTransactionRepository interface. */
+export interface ReadonlyIterableTransactionRepository extends TransactionReadRepository, TransactionRepositoryIterator {}
+
+/** IterableTransactionRepository interface. */
+export interface IterableTransactionRepository extends TransactionRepository, TransactionRepositoryIterator {}

package/src/repository/TransactionRepositoryIterator.ts

@@ -0,0 +1,6 @@
+import type { SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness } from '@xyo-network/xl1-protocol-model'
+
+import type { IterableRepository } from './Repository.ts'
+
+/** TransactionRepositoryIterator interface. */
+export interface TransactionRepositoryIterator extends IterableRepository<TransactionBoundWitness, SignedHydratedTransactionWithStorageMeta | undefined> {}

package/src/repository/TransactionWriteRepository.ts

@@ -0,0 +1,6 @@
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol-model'
+
+import type { WriteRepository } from './Repository.ts'
+
+/** TransactionWriteRepository interface. */
+export interface TransactionWriteRepository extends WriteRepository<SignedHydratedTransaction, boolean> {}

package/src/repository/index.ts

@@ -0,0 +1,5 @@
+export * from './Repository.ts'
+export * from './TransactionReadRepository.ts'
+export * from './TransactionRepository.ts'
+export * from './TransactionRepositoryIterator.ts'
+export * from './TransactionWriteRepository.ts'

package/src/runners/Block.ts

@@ -0,0 +1,21 @@
+import type { WithHashMeta } from '@xyo-network/sdk-js'
+import type {
+  BlockBoundWitness, Provider,
+  SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol-model'
+
+/** BlockRunnerMethods interface. */
+export interface BlockRunnerMethods {
+  produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force: true): Promise<SignedHydratedBlockWithHashMeta>
+  produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force?: false): Promise<SignedHydratedBlockWithHashMeta | undefined>
+}
+
+/** Moniker identifier for the BlockRunner provider. */
+export const BlockRunnerMoniker = 'BlockRunner' as const
+/** Type literal for the BlockRunner provider moniker. */
+export type BlockRunnerMoniker = typeof BlockRunnerMoniker
+
+/** Runner interface for executing Block operations. */
+export interface BlockRunner extends BlockRunnerMethods, Provider<BlockRunnerMoniker> {
+  next(head: WithHashMeta<BlockBoundWitness>): Promise<SignedHydratedBlockWithHashMeta | undefined>
+}

package/src/runners/Finalization.ts

@@ -0,0 +1,17 @@
+import type { Hash } from '@xylabs/sdk-js'
+import type { Provider, SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol-model'
+
+/** FinalizationRunnerMethods interface. */
+export interface FinalizationRunnerMethods {
+  finalizeBlocks(blocks: SignedHydratedBlockWithHashMeta[]): Promise<Hash[]>
+}
+
+/** Moniker identifier for the FinalizationRunner provider. */
+export const FinalizationRunnerMoniker = 'FinalizationRunner' as const
+/** Type literal for the FinalizationRunner provider moniker. */
+export type FinalizationRunnerMoniker = typeof FinalizationRunnerMoniker
+
+/** Runner interface for executing Finalization operations. */
+export interface FinalizationRunner extends FinalizationRunnerMethods, Provider<FinalizationRunnerMoniker> {
+  finalizeBlock(block: SignedHydratedBlockWithHashMeta): Promise<Hash>
+}

package/src/runners/Mempool.ts

@@ -0,0 +1,31 @@
+import type { Hash } from '@xylabs/sdk-js'
+import type {
+  Provider, SignedHydratedBlock, SignedHydratedTransaction,
+} from '@xyo-network/xl1-protocol-model'
+
+/** MempoolRunnerMethods interface. */
+export interface MempoolRunnerMethods {
+  submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]>
+  submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]>
+}
+
+/** Moniker identifier for the MempoolRunner provider. */
+export const MempoolRunnerMoniker = 'MempoolRunner' as const
+/** Type literal for the MempoolRunner provider moniker. */
+export type MempoolRunnerMoniker = typeof MempoolRunnerMoniker
+
+/** DEFAULT_MAX_EXP_AHEAD constant. */
+export const DEFAULT_MAX_EXP_AHEAD = 1000
+
+/** Options for MempoolPrune. */
+export interface MempoolPruneOptions {
+  batchSize?: number
+  maxCheck?: number
+  maxPrune?: number
+}
+
+/** Runner interface for executing Mempool operations. */
+export interface MempoolRunner extends MempoolRunnerMethods, Provider<MempoolRunnerMoniker> {
+  prunePendingBlocks(options?: MempoolPruneOptions): Promise<[number, number]>
+  prunePendingTransactions(options?: MempoolPruneOptions): Promise<[number, number]>
+}

package/src/runners/index.ts

@@ -0,0 +1,3 @@
+export * from './Block.ts'
+export * from './Finalization.ts'
+export * from './Mempool.ts'

package/src/validation/block/BlockValidationFunction.ts

@@ -0,0 +1,13 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type {
+  BaseContext, BlockBoundWitness, ChainId,
+} from '@xyo-network/xl1-protocol-model'
+
+import type { BlockValidationError } from './error.ts'
+
+/** Function type for BlockValidator operations. */
+export type BlockValidatorFunction = (
+  context: BaseContext,
+  block: BlockBoundWitness,
+  chainId?: ChainId,
+) => Promisable<BlockValidationError[]>

package/src/validation/block/HydratedBlockStateValidationFunction.ts

@@ -0,0 +1,29 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type {
+  AccountBalanceViewer,
+  BaseContext, ChainId,
+  HydratedBlockWithHashMeta, XL1BlockNumber,
+} from '@xyo-network/xl1-protocol-model'
+
+import type { HydratedBlockStateValidationError } from './error.ts'
+
+/** Function type for ChainAtBlockNumber operations. */
+export type ChainAtBlockNumberFunction = (blockNumber: XL1BlockNumber) => Promisable<ChainId>
+
+/** Context for HydratedBlockStateValidationFunction operations. */
+export interface HydratedBlockStateValidationFunctionContext extends BaseContext {
+  accountBalance: AccountBalanceViewer
+  chainIdAtBlockNumber: ChainAtBlockNumberFunction
+}
+
+/**
+ * A function that validates a hydrated block against chain state.
+ * @param hydratedBlock The hydrated block to validate.
+ * @param chainId The chain ID to use for validation.
+ * @param archivist The archivist to use for validation.
+ * @returns An array of errors if the block is invalid, or an empty array if it is valid.
+ */
+export type HydratedBlockStateValidationFunction = (
+  context: HydratedBlockStateValidationFunctionContext,
+  hydratedBlock: HydratedBlockWithHashMeta,
+) => Promisable<HydratedBlockStateValidationError[]>