@xyo-network/xl1-protocol-sdk 1.26.12 → 1.26.14

package/src/simple/datalake/RestDataLakeRunner.ts

@@ -1,54 +0,0 @@
-import {
-  assertEx, BrandedHash, exists, type Hash,
-  Promisable,
-  PromisableArray,
-} from '@xylabs/sdk-js'
-import { isAnyPayload, PayloadZodLoose } from '@xyo-network/sdk-js'
-import {
-  DataLakeData,
-  DataLakeRunner,
-  DataLakeRunnerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-import { AxiosResponse } from 'axios'
-import z from 'zod'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractRestDataLake } from './AbstractRestDataLake.ts'
-import { RestDataLakeViewerParams } from './RestDataLakeViewer.ts'
-
-/** Parameters for RestDataLakeRunner. */
-export interface RestDataLakeRunnerParams extends RestDataLakeViewerParams {}
-
-/** RestDataLakeRunner implementation. */
-@creatableProvider()
-export class RestDataLakeRunner<TParams extends RestDataLakeRunnerParams> extends
-  AbstractRestDataLake<TParams> implements DataLakeRunner {
-  static readonly defaultMoniker = DataLakeRunnerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeRunnerMoniker]
-  moniker = RestDataLakeRunner.defaultMoniker
-
-  clear(): Promisable<void> {
-    throw new Error('Method not implemented.')
-  }
-
-  delete(_hashes: BrandedHash[]): PromisableArray<DataLakeData> {
-    throw new Error('Method not implemented.')
-  }
-
-  async insert(items: DataLakeData[]): Promise<DataLakeData[]> {
-    const allowedItems = items.map((item) => {
-      if (isAnyPayload(item) && this.isAllowed(item)) {
-        assertEx(typeof item === 'object' && item !== null, () => 'Data must be an object')
-        return item
-      }
-      return null
-    }).filter(exists)
-    if (allowedItems.length > 0) {
-      const result = await this.axios.post<DataLakeData[], AxiosResponse<Hash[]>>(`${this.params.endpoint}/insert`, allowedItems)
-      return z.array(PayloadZodLoose).parse(result.data)
-    } else {
-      return []
-    }
-  }
-}

package/src/simple/datalake/RestDataLakeViewer.ts

@@ -1,22 +0,0 @@
-import {
-  DataLakeViewer,
-  DataLakeViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractRestDataLake, AbstractRestDataLakeParams } from './AbstractRestDataLake.ts'
-
-/** Parameters for RestDataLakeViewer. */
-export interface RestDataLakeViewerParams extends
-  AbstractRestDataLakeParams {
-}
-
-/** RestDataLakeViewer implementation. */
-@creatableProvider()
-export class RestDataLakeViewer<TParams extends RestDataLakeViewerParams = RestDataLakeViewerParams>
-  extends AbstractRestDataLake<TParams> implements DataLakeViewer {
-  static readonly defaultMoniker = DataLakeViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeViewerMoniker]
-  moniker = RestDataLakeViewer.defaultMoniker
-}

package/src/simple/datalake/SimpleDataLakeRunner.ts

@@ -1,44 +0,0 @@
-import { exists, type Hash } from '@xylabs/sdk-js'
-import { isAnyPayload, PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  DataLakeData,
-  DataLakeRunner,
-  DataLakeRunnerMoniker, MapType,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractSimpleDataLake } from './AbstractSimpleDataLake.ts'
-import { SimpleDataLakeViewerParams } from './SimpleDataLakeViewer.ts'
-
-/** Parameters for SimpleDataLakeRunner. */
-export interface SimpleDataLakeRunnerParams extends SimpleDataLakeViewerParams<MapType<Hash, DataLakeData>> {}
-
-/** SimpleDataLakeRunner implementation. */
-@creatableProvider()
-export class SimpleDataLakeRunner<TParams extends SimpleDataLakeRunnerParams> extends
-  AbstractSimpleDataLake<TParams> implements DataLakeRunner {
-  static readonly defaultMoniker = DataLakeRunnerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeRunnerMoniker]
-  moniker = SimpleDataLakeRunner.defaultMoniker
-
-  async clear(): Promise<void> {
-    await this.map.clear()
-  }
-
-  async delete(hashes: Hash[]) {
-    return (await Promise.all(hashes.map(async (hash) => {
-      const payload = await this.map.get(hash)
-      return (await this.map.delete(hash)) ? payload : undefined
-    }))).filter(exists)
-  }
-
-  async insert(items: DataLakeData[]) {
-    const payloads = items.filter(isAnyPayload).filter(i => this.isAllowed(i))
-    const hashPairs = await PayloadBuilder.hashPairs(payloads)
-    for (const [payload, hash] of hashPairs) {
-      await this.map.set(hash, payload)
-    }
-    return hashPairs.map(([payload]) => payload)
-  }
-}

package/src/simple/datalake/SimpleDataLakeViewer.ts

@@ -1,24 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import {
-  DataLakeData,
-  DataLakeViewer,
-  DataLakeViewerMoniker, MapTypeRead,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractSimpleDataLake, AbstractSimpleDataLakeParams } from './AbstractSimpleDataLake.ts'
-
-/** Parameters for SimpleDataLakeViewer. */
-export interface SimpleDataLakeViewerParams<TMap extends MapTypeRead<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData>> extends
-  AbstractSimpleDataLakeParams<TMap> {
-}
-
-/** SimpleDataLakeViewer implementation. */
-@creatableProvider()
-export class SimpleDataLakeViewer<TParams extends SimpleDataLakeViewerParams = SimpleDataLakeViewerParams>
-  extends AbstractSimpleDataLake<TParams> implements DataLakeViewer {
-  static readonly defaultMoniker = DataLakeViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeViewerMoniker]
-  moniker = SimpleDataLakeViewer.defaultMoniker
-}

package/src/simple/datalake/index.ts

@@ -1,4 +0,0 @@
-export * from './RestDataLakeRunner.ts'
-export * from './RestDataLakeViewer.ts'
-export * from './SimpleDataLakeRunner.ts'
-export * from './SimpleDataLakeViewer.ts'

package/src/simple/finalization/SimpleFinalizationRunner.ts

@@ -1,45 +0,0 @@
-import { type Hash } from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/sdk-js'
-import { type SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-import { FinalizationRunner, FinalizationRunnerMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { ChainStoreWrite } from '../../model/index.ts'
-
-/** Parameters for SimpleFinalizationRunner. */
-export interface SimpleFinalizationRunnerParams extends CreatableProviderParams {
-  finalizedArchivist: ArchivistInstance
-}
-
-/** SimpleFinalizationRunner implementation. */
-@creatableProvider()
-export class SimpleFinalizationRunner extends AbstractCreatableProvider<SimpleFinalizationRunnerParams> implements FinalizationRunner {
-  static readonly defaultMoniker = FinalizationRunnerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [FinalizationRunnerMoniker]
-  moniker = SimpleFinalizationRunner.defaultMoniker
-
-  protected _store: ChainStoreWrite | undefined
-
-  protected get store() {
-    return this._store!
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._store = { chainMap: this.params.finalizedArchivist }
-  }
-
-  async finalizeBlock(block: SignedHydratedBlockWithHashMeta): Promise<Hash> {
-    return (await this.finalizeBlocks([block]))[0]
-  }
-
-  async finalizeBlocks(blocks: SignedHydratedBlockWithHashMeta[]): Promise<Hash[]> {
-    const sortedBlocks = blocks.toSorted((a, b) => a[0].block - b[0].block)
-    const payloads = sortedBlocks.flatMap(block => [...block[1], block[0]])
-    await this.store.chainMap.insert(payloads)
-    return sortedBlocks.map(b => b[0]._hash)
-  }
-}

package/src/simple/finalization/SimpleFinalizationViewer.ts

@@ -1,123 +0,0 @@
-import {
-  assertEx,
-  Hash,
-} from '@xylabs/sdk-js'
-import type { ReadArchivist } from '@xyo-network/sdk-js'
-import {
-  asSignedHydratedBlockWithStorageMeta, BlockContextRead, ChainContextRead, ChainContractViewerMoniker, ChainId, FinalizationViewer,
-  FinalizationViewerMoniker, type SignedBlockBoundWitnessWithHashMeta, type SignedHydratedBlockWithHashMeta,
-  SignedHydratedBlockWithStorageMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { hydrateBlock } from '../../block/index.ts'
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { ChainStoreRead } from '../../model/index.ts'
-import { findMostRecentBlock } from '../../primitives/index.ts'
-import { HydratedCache } from '../../utils/index.ts'
-
-/** Parameters for SimpleFinalizationViewer. */
-export interface SimpleFinalizationViewerParams extends CreatableProviderParams {
-  finalizedArchivist: ReadArchivist
-}
-
-/** SimpleFinalizationViewer implementation. */
-@creatableProvider()
-export class SimpleFinalizationViewer extends AbstractCreatableProvider<SimpleFinalizationViewerParams> implements FinalizationViewer {
-  static readonly defaultMoniker = FinalizationViewerMoniker
-  static readonly dependencies = [ChainContractViewerMoniker]
-  static readonly monikers = [FinalizationViewerMoniker]
-  moniker = SimpleFinalizationViewer.defaultMoniker
-
-  protected _chainId!: ChainId
-  protected _store: ChainStoreRead | undefined
-
-  private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithStorageMeta> | undefined
-
-  protected get finalizedArchivist() {
-    return this.params.finalizedArchivist
-  }
-
-  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithStorageMeta> {
-    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
-    const context = this.getBlockContextRead()
-    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithStorageMeta>(context, async (
-      store: ChainStoreRead,
-      hash: Hash,
-      maxDepth?: number,
-      minDepth?: number,
-    ) => {
-      const result = await hydrateBlock(context, hash, maxDepth, minDepth)
-      return asSignedHydratedBlockWithStorageMeta(result, true)
-    }, 200)
-    return this._signedHydratedBlockCache
-  }
-
-  protected get store() {
-    return this._store!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleFinalizationViewerParams>) {
-    return {
-      ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required'),
-    } satisfies SimpleFinalizationViewerParams
-  }
-
-  chainId() {
-    return this._chainId
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._chainId = assertEx(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => 'chain.id is required if empty archivist')
-    this._store = { chainMap: this.params.finalizedArchivist }
-  }
-
-  async head(): Promise<SignedHydratedBlockWithHashMeta> {
-    return await this.spanAsync('head', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlock]')
-      const cache = this.hydratedBlockCache
-      const block = await cache.get(currentHead._hash)
-      if (!block) {
-        console.log(`Could not find current block with hash ${currentHead!._hash}`)
-      }
-      return assertEx(block, () => 'Could not find current block')
-    }, this.context)
-  }
-
-  async headBlock(): Promise<SignedBlockBoundWitnessWithHashMeta> {
-    return (await this.head())[0]
-  }
-
-  async headHash(): Promise<Hash> {
-    return (await this.headBlock())._hash
-  }
-
-  async headNumber(): Promise<XL1BlockNumber> {
-    return (await this.headBlock()).block
-  }
-
-  protected getBlockContextRead(): BlockContextRead {
-    return {
-      ...this.context,
-      chainMap: this.store.chainMap,
-    }
-  }
-
-  protected async getChainContextRead(): Promise<ChainContextRead> {
-    return {
-      ...this.getBlockContextRead(),
-      head: (await this.head())[0],
-    }
-  }
-
-  protected async getCurrentHead() {
-    const chainArchivist = this.finalizedArchivist
-    const result = assertEx(await findMostRecentBlock(chainArchivist), () => 'Could not find most recent block [getCurrentHead]')
-    assertEx(result?.chain === this._chainId, () => 'Chain ID does not match head block chain ID')
-    return result
-  }
-}

package/src/simple/finalization/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleFinalizationRunner.ts'
-export * from './SimpleFinalizationViewer.ts'

package/src/simple/gateway/SimpleXyoGateway.ts

@@ -1,30 +0,0 @@
-import type {
-  XyoConnection,
-  XyoGateway,
-} from '@xyo-network/xl1-protocol-lib'
-import { XyoConnectionMoniker, XyoGatewayMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleXyoGateway. */
-export interface SimpleXyoGatewayParams extends CreatableProviderParams {}
-
-/** SimpleXyoGateway implementation. */
-export class SimpleXyoGateway extends AbstractCreatableProvider<SimpleXyoGatewayParams> implements XyoGateway {
-  static readonly defaultMoniker = XyoGatewayMoniker
-  static readonly dependencies = [XyoConnectionMoniker]
-  static readonly monikers = [XyoGatewayMoniker]
-  moniker = SimpleXyoGateway.defaultMoniker
-
-  private _connection!: XyoConnection
-
-  get connection(): XyoConnection {
-    return this._connection
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._connection = await this.locator.getInstance<XyoConnection>(XyoConnectionMoniker)
-  }
-}

package/src/simple/gateway/SimpleXyoGatewayRunner.ts

@@ -1,137 +0,0 @@
-import type {
-  Address, Hash, Hex,
-} from '@xylabs/sdk-js'
-import {
-  assertEx, BigIntToJsonZod, isDefined,
-} from '@xylabs/sdk-js'
-import { type Payload, type WithHashMeta } from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, AttoXL1, ConfirmSubmittedTransactionOptions,
-  DataLakeRunner, SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta, TransactionOptions, Transfer, UnsignedHydratedTransaction,
-  XyoConnection, XyoGatewayRunner, XyoSigner,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asXL1BlockNumber, DataLakeRunnerMoniker, isSignedHydratedTransaction, TransferSchema, XyoConnectionMoniker, XyoGatewayMoniker, XyoGatewayRunnerMoniker, XyoSignerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
-import {
-  buildUnsignedTransaction, confirmSubmittedTransaction, flattenHydratedTransaction,
-} from '../../transaction/index.ts'
-
-/** Parameters for SimpleXyoGatewayRunner. */
-export interface SimpleXyoGatewayRunnerParams extends CreatableProviderParams {
-
-}
-
-/** SimpleXyoGatewayRunner implementation. */
-export class SimpleXyoGatewayRunner extends AbstractCreatableProvider<SimpleXyoGatewayRunnerParams> implements XyoGatewayRunner {
-  static readonly defaultMoniker = XyoGatewayRunnerMoniker
-  static readonly dependencies = [XyoConnectionMoniker, XyoSignerMoniker]
-  static readonly monikers = [XyoGatewayRunnerMoniker, XyoGatewayMoniker]
-  moniker = SimpleXyoGatewayRunner.defaultMoniker
-
-  private _connection!: XyoConnection
-  private _dataLakeRunner?: DataLakeRunner
-  private _signer!: XyoSigner
-
-  get connection(): XyoConnection {
-    return this._connection
-  }
-
-  get dataLakeRunner(): DataLakeRunner | undefined {
-    return this._dataLakeRunner
-  }
-
-  get signer(): XyoSigner {
-    return this._signer
-  }
-
-  async addPayloadsToChain(
-    onChain: AllowedBlockPayload[],
-    offChain: Payload[],
-    options?: TransactionOptions,
-  ): Promise<[Hash, SignedHydratedTransactionWithHashMeta]> {
-    // Get chain providers
-    const viewer = assertEx(this.connection.viewer, () => 'No viewer available on connection')
-
-    // Resolve transaction options
-    const {
-      nbf, exp, chain, fees,
-    } = options ?? {}
-    const resolvedChainId = isDefined(chain) ? chain : await viewer.chainId()
-    const resolvedNbf = asXL1BlockNumber(isDefined(nbf) ? nbf : await viewer.currentBlockNumber(), true)
-    const resolvedExp = asXL1BlockNumber(isDefined(exp) ? exp : resolvedNbf + 10, true)
-
-    // Build, sign, and broadcast the transaction
-    const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees)
-    return await this.addTransactionToChain(tx, await PayloadBuilder.addHashMeta(offChain))
-  }
-
-  async addTransactionToChain(
-    tx: UnsignedHydratedTransaction | SignedHydratedTransaction,
-    offChain: WithHashMeta<Payload>[] = [],
-  ): Promise<[Hash, SignedHydratedTransactionWithHashMeta]> {
-    const connection = this.connection
-
-    const signer = this.signer
-    const runner = assertEx(connection.runner, () => 'No runner available on connection')
-
-    // Prepare for returning the SignedHydratedTransactionWithHashMeta
-    let signedTx: SignedHydratedTransactionWithHashMeta
-
-    // If the supplied transaction is already signed
-    if (isSignedHydratedTransaction(tx)) {
-      // Ensure it has hash meta
-      const [bw, payloads] = tx
-      const hashedBw = await PayloadBuilder.addHashMeta(bw)
-      const hashedPayloads = await PayloadBuilder.addHashMeta(payloads)
-      signedTx = [hashedBw, hashedPayloads]
-    } else {
-      // Otherwise, sign it using our signer
-      signedTx = await signer.signTransaction(tx)
-    }
-
-    await this._dataLakeRunner?.insert([...flattenHydratedTransaction(signedTx), ...offChain])
-
-    // Broadcast the transaction
-    return [await runner.broadcastTransaction([signedTx[0], signedTx[1]]), signedTx]
-  }
-
-  async confirmSubmittedTransaction(txHash: Hash, options?: ConfirmSubmittedTransactionOptions): Promise<SignedHydratedTransaction> {
-    return await confirmSubmittedTransaction(
-      assertEx(this.connection.viewer, () => 'Connection viewer is undefined'),
-      txHash,
-      options,
-    )
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._connection = await this.locator.getInstance<XyoConnection>(XyoConnectionMoniker)
-    this._signer = await this.locator.getInstance<XyoSigner>(XyoSignerMoniker)
-    this._dataLakeRunner = await this.locator.tryGetInstance<DataLakeRunner>(DataLakeRunnerMoniker)
-  }
-
-  async send(to: Address, amount: AttoXL1, options?: TransactionOptions): Promise<Hash> {
-    return await this.sendMany({ [to]: amount }, options)
-  }
-
-  async sendMany(transfers: Record<Address, AttoXL1>, options?: TransactionOptions): Promise<Hash> {
-    const from = await this.signer.address()
-    const hexTransfers: Record<Address, Hex> = Object.fromEntries(
-      Object.entries(transfers).map(([address, amount]) => ([
-        address, BigIntToJsonZod.parse(amount),
-      ])),
-    )
-    const transfer = new PayloadBuilder<Transfer>({ schema: TransferSchema }).fields({
-      from,
-      transfers: hexTransfers,
-      epoch: Date.now(),
-    }).build()
-    const [hash] = await this.addPayloadsToChain([transfer], [], options)
-    return hash
-  }
-}

package/src/simple/gateway/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleXyoGateway.ts'
-export * from './SimpleXyoGatewayRunner.ts'

package/src/simple/index.ts

@@ -1,22 +0,0 @@
-export * from './accountBalance/index.ts'
-export * from './block/index.ts'
-export * from './blockReward/index.ts'
-export * from './blockValidation/index.ts'
-export * from './chainContractViewer/index.ts'
-export * from './client/index.ts'
-export * from './datalake/index.ts'
-export * from './finalization/index.ts'
-export * from './gateway/index.ts'
-export * from './mempool/index.ts'
-export * from './network/index.ts'
-export * from './permissions/index.ts'
-export * from './runner/index.ts'
-export * from './signer/index.ts'
-export * from './StakeEventsViewer/index.ts'
-export * from './StakeTotalsViewer/index.ts'
-export * from './StakeViewer/index.ts'
-export * from './timeSync2/index.ts'
-export * from './transactionValidation/index.ts'
-export * from './transactionValidation/index.ts'
-export * from './TransactionViewer/index.ts'
-export * from './windowedBlock/index.ts'