@xyo-network/xl1-protocol-sdk 1.26.11 → 1.26.13

package/src/simple/mempool/SimpleMempoolViewer.ts

@@ -1,215 +0,0 @@
-import {
-  exists, isDefined, isHash,
-} from '@xylabs/sdk-js'
-import type {
-  ArchivistInstance,
-  HashMeta,
-  PayloadBundle, Sequence,
-} from '@xyo-network/sdk-js'
-import { isHashMeta, isPayloadBundle } from '@xyo-network/sdk-js'
-import {
-  type HydratedTransactionWithHashMeta, type MempoolViewer, MempoolViewerMoniker,
-  PendingTransactionsOptions,
-  type SignedHydratedBlockWithHashMeta, type SignedHydratedTransactionWithHashMeta,
-  WindowedBlockViewer,
-  WindowedBlockViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { bundledPayloadToHydratedBlock, bundledPayloadToHydratedTransaction } from '../../model/index.ts'
-
-type PayloadBundleWithHashMeta = PayloadBundle & HashMeta
-
-type HydratedTxWithBundle = {
-  bundle: PayloadBundleWithHashMeta
-  tx: SignedHydratedTransactionWithHashMeta
-}
-
-/** Default maximum fraction of mempool transactions to return. */
-const DEFAULT_MEMPOOL_SELECTION_RATIO = 0.66
-
-/** Parameters for SimpleMempoolViewer. */
-export interface SimpleMempoolViewerParams extends CreatableProviderParams {
-  /** External mempool viewers (reserved for future use). */
-  externalMempools?: MempoolViewer[]
-  /** Maximum fraction (0–1) of mempool inclusion candidates to return. Defaults to 0.66. */
-  mempoolSelectionRatio?: number
-  pendingBlocksArchivist: ArchivistInstance
-  pendingTransactionsArchivist: ArchivistInstance
-}
-
-/** SimpleMempoolViewer implementation. */
-@creatableProvider()
-export class SimpleMempoolViewer extends AbstractCreatableProvider<SimpleMempoolViewerParams> implements MempoolViewer {
-  static readonly defaultMoniker = MempoolViewerMoniker
-  static readonly dependencies = [WindowedBlockViewerMoniker]
-  static readonly monikers = [MempoolViewerMoniker]
-  moniker = SimpleMempoolViewer.defaultMoniker
-
-  private _windowedBlockViewer?: WindowedBlockViewer
-
-  protected get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist
-  }
-
-  protected get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist
-  }
-
-  protected get windowedBlockViewer() {
-    return this._windowedBlockViewer!
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._windowedBlockViewer = await this.locator.getInstance<WindowedBlockViewer>(WindowedBlockViewerMoniker)
-  }
-
-  async pendingBlocks({ cursor: providedCursor }: PendingTransactionsOptions = {}): Promise<SignedHydratedBlockWithHashMeta[]> {
-    let cursor: Sequence | undefined = undefined
-    if (isHash(providedCursor)) {
-      const [p] = await this.pendingBlocksArchivist.get([providedCursor])
-      if (isDefined(p)) {
-        cursor = p._sequence
-      }
-    }
-    const bundles = await this.pendingBlocksArchivist.next({
-      order: 'desc', limit: 100, cursor,
-    })
-    const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta)
-    return (await Promise.all(filteredBundles.map(async bundle => await bundledPayloadToHydratedBlock(bundle)))).filter(exists)
-  }
-
-  async pendingTransactions({
-    cursor: providedCursor,
-    limit = 100,
-  }: PendingTransactionsOptions = {}): Promise<SignedHydratedTransactionWithHashMeta[]> {
-    let cursor: Sequence | undefined = undefined
-    if (isHash(providedCursor)) {
-      const [p] = await this.pendingTransactionsArchivist.get([providedCursor])
-      if (isDefined(p)) {
-        cursor = p._sequence
-      }
-    }
-    this.logger?.info(`Fetching pending transactions from cursor: ${cursor}`)
-    const bundles = (await this.pendingTransactionsArchivist.next({
-      order: 'asc', limit: limit * 5, cursor,
-    }))
-
-    this.logger?.info(`Fetched pending transactions: ${bundles.length} bundles`)
-
-    const filteredBundles: PayloadBundleWithHashMeta[] = bundles.filter(isPayloadBundle).filter(isHashMeta)
-    // this.logger?.info(`Filtered pending transactions: ${JSON.stringify(filteredBundles, null, 2)} filteredBundles`)
-
-    const hydratedWithBundle: HydratedTxWithBundle[] = (await Promise.all(
-      filteredBundles.map(async (bundle) => {
-        const tx = await bundledPayloadToHydratedTransaction(bundle)
-        return isDefined(tx) ? { bundle, tx } : undefined
-      }),
-    )).filter(exists)
-    // this.logger?.info(`Converted pending transactions: ${JSON.stringify(hydratedWithBundle.map(x => x.tx), null, 2)} results`)
-
-    const currentBlock = await this.windowedBlockViewer.currentBlock()
-    const evaluated = await Promise.all(
-      hydratedWithBundle.map(async ({ bundle, tx }) => ({
-        bundle, tx, deletable: await this.isDeletable(tx, currentBlock),
-      })),
-    )
-
-    const validTransactions = evaluated.filter(x => !x.deletable)
-    const deletionCandidates = evaluated.filter(x => x.deletable)
-    this.logger?.info(`Pending transactions: ${validTransactions.length} valid, ${deletionCandidates.length} not deletable`)
-
-    // Delete the invalid transactions that should not remain in the mempool.
-    await Promise.all(
-      deletionCandidates.map(async ({ bundle, tx }) => {
-        await this.deleteBundledTransaction(bundle)
-        this.logger?.info(`Purged completed/expired bundled transaction: ${bundle._hash}/${tx[0]._hash}`)
-      }),
-    )
-
-    const inclusionCandidates = (await Promise.all(validTransactions.map(x => x.tx).map(async (tx) => {
-      // Check if it's a candidate for inclusion (skip deletable check as we've already done that)
-      if (await this.isInclusionCandidate(tx, currentBlock, false)) return tx
-    }))).filter(exists)
-
-    const selectionRatio = this.params.mempoolSelectionRatio ?? DEFAULT_MEMPOOL_SELECTION_RATIO
-    const maxByRatio = Math.ceil(inclusionCandidates.length * selectionRatio)
-    const effectiveLimit = Math.min(limit, maxByRatio)
-
-    const randomInclusionCandidates = deduplicateBySigner(
-      inclusionCandidates.filter(() => Math.random() < selectionRatio),
-    ).slice(0, effectiveLimit)
-
-    // if the random filter resulted in 0 bundles, we fallback to just taking the first bundle to ensure we return something
-    const result = randomInclusionCandidates.length > 0 ? randomInclusionCandidates : deduplicateBySigner(inclusionCandidates).slice(0, 1)
-
-    this.logger?.info(`Inclusion candidates: ${inclusionCandidates.length}`)
-    return result
-  }
-
-  private async deleteBundledTransaction(bundle: PayloadBundleWithHashMeta): Promise<void> {
-    await this.pendingTransactionsArchivist.delete([bundle._hash])
-  }
-
-  /**
-   * Evaluates a transaction to determine if it should be purged from the mempool.
-   * @param tx The transaction to evaluate
-   * @param currentBlock The current block to use for evaluation
-   * @returns True if the transaction should be purged, false otherwise
-   */
-  private async isDeletable(tx: HydratedTransactionWithHashMeta, currentBlock: SignedHydratedBlockWithHashMeta): Promise<boolean> {
-    const currentBlockNumber = currentBlock[0].block
-    const nextBlockNumber = currentBlockNumber + 1
-    const { exp } = tx[0]
-
-    // If it's expired
-    if (nextBlockNumber > exp) return true
-
-    // If it's already included in a block
-    const existingBlock = await this.windowedBlockViewer.blockByTransactionHash(tx[0]._hash)
-    if (existingBlock) return true
-
-    return false
-  }
-
-  /**
-   * Evaluates a transaction to determine if is valid for inclusion in the next block. A transaction is invalid if:
-   * - The transaction is too early/expired
-   * - The transaction has already been included in a block
-   * @param tx The transaction to evaluate
-   * @param currentBlock The current block to use for evaluation
-   * @param checkForDeletable Whether to check if the transaction is deletable (default: true)
-   * @returns True if the transaction is valid for inclusion in the next block, false otherwise
-   */
-  private async isInclusionCandidate(
-    tx: HydratedTransactionWithHashMeta,
-    currentBlock: SignedHydratedBlockWithHashMeta,
-    checkForDeletable: boolean = true,
-  ): Promise<boolean> {
-    const currentBlockNumber = currentBlock[0].block
-    const nextBlockNumber = currentBlockNumber + 1
-    const { nbf } = tx[0]
-
-    // If it's not time yet
-    if (nextBlockNumber < nbf) return false
-
-    // If it's deletable
-    if (checkForDeletable && await this.isDeletable(tx, currentBlock)) return false
-
-    return true
-  }
-}
-
-/** Remove transactions that share the same signer set, keeping the first occurrence. */
-function deduplicateBySigner(txs: SignedHydratedTransactionWithHashMeta[]): SignedHydratedTransactionWithHashMeta[] {
-  const seen = new Set<string>()
-  return txs.filter((tx) => {
-    const key = tx[0].addresses.toSorted().join(',')
-    if (seen.has(key)) return false
-    seen.add(key)
-    return true
-  })
-}

package/src/simple/mempool/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleMempoolRunner.ts'
-export * from './SimpleMempoolViewer.ts'

package/src/simple/network/SimpleXyoNetwork.ts

@@ -1,48 +0,0 @@
-import { isUndefined } from '@xylabs/sdk-js'
-import type {
-  GatewayName,
-  NetworkStatus, XyoNetwork,
-} from '@xyo-network/xl1-protocol-lib'
-import { isNetworkStatus } from '@xyo-network/xl1-protocol-lib'
-import axios from 'axios'
-
-import {
-  errorStatus, StatusNetworks, unknownStatus,
-} from './lib/index.ts'
-
-/** SimpleXyoNetwork implementation. */
-export class SimpleXyoNetwork implements XyoNetwork {
-  protected readonly _networkId: GatewayName
-
-  constructor(networkId: GatewayName) {
-    this._networkId = networkId
-  }
-
-  async status(): Promise<NetworkStatus> {
-    const statusNetwork = StatusNetworks[this._networkId]
-    if (isUndefined(statusNetwork)) {
-      throw new Error(`Unknown status network ID: ${this._networkId}`)
-    }
-
-    return await this.makeRequest(statusNetwork.statusUrl)
-  }
-
-  private async makeRequest(url: string): Promise<NetworkStatus> {
-    try {
-      const response = await axios.get(url)
-      if (isNetworkStatus(response.data)) {
-        return response.data
-      } else {
-        if (response.status === 200) {
-          console.error('Unknown network status response:', response.data)
-
-          return unknownStatus
-        }
-        return errorStatus
-      }
-    } catch (error) {
-      console.error('Error fetching network status:', error)
-      return errorStatus
-    }
-  }
-}

package/src/simple/network/index.ts

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

package/src/simple/network/lib/FailedNetworkStatusPayloads.ts

@@ -1,16 +0,0 @@
-import type { NetworkStatus } from '@xyo-network/xl1-protocol-lib'
-import { NetworkStatusSchema } from '@xyo-network/xl1-protocol-lib'
-
-/** unknownStatus constant. */
-export const unknownStatus: NetworkStatus = {
-  description: 'Unknown Network Status',
-  schema: NetworkStatusSchema,
-  state: 'unknown',
-}
-
-/** errorStatus constant. */
-export const errorStatus: NetworkStatus = {
-  description: 'Error Fetching Network Status',
-  schema: NetworkStatusSchema,
-  state: 'unknown',
-}

package/src/simple/network/lib/StatusNetworks.ts

@@ -1,32 +0,0 @@
-import type { GatewayName } from '@xyo-network/xl1-protocol-lib'
-
-/** StatusNetwork type. */
-export type StatusNetwork = {
-  id: GatewayName
-  statusUrl: string
-}
-
-/** MainNetworkStats constant. */
-export const MainNetworkStats: StatusNetwork = {
-  id: 'mainnet' as GatewayName,
-  statusUrl: 'https://xyo.network/chain-network-status-mainnet.json',
-}
-
-/** SequenceNetworkStats constant. */
-export const SequenceNetworkStats: StatusNetwork = {
-  id: 'sequence' as GatewayName,
-  statusUrl: 'https://beta.xyo.network/chain-network-status-sequence.json',
-}
-
-/** LocalNetworkStats constant. */
-export const LocalNetworkStats: StatusNetwork = {
-  id: 'local' as GatewayName,
-  statusUrl: 'http://localhost:3002/chain-network-status-local.json',
-}
-
-/** StatusNetworks constant. */
-export const StatusNetworks: Record<GatewayName, StatusNetwork> = {
-  ['mainnet' as GatewayName]: MainNetworkStats,
-  ['sequence' as GatewayName]: SequenceNetworkStats,
-  ['local' as GatewayName]: LocalNetworkStats,
-}

package/src/simple/network/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './FailedNetworkStatusPayloads.ts'
-export * from './StatusNetworks.ts'

package/src/simple/permissions/SimpleXyoPermissions.ts

@@ -1,82 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  CaveatTypes,
-  InvokerPermission, PermissionRequest, RequestedPermission, XyoPermissions,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { Invoker, PermissionsStore } from './store/index.ts'
-
-/**
- * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
- * Does not persist data beyond the lifetime of the instance.
- * Assumes all permission requests are granted and revocations always succeed.
- */
-export class SimpleXyoPermissions implements XyoPermissions {
-  invoker: Invoker
-  private _store: PermissionsStore
-
-  constructor(store: PermissionsStore) {
-    this._store = store
-    this.invoker = store.invoker
-  }
-
-  get store(): PermissionsStore {
-    return assertEx(this._store, () => 'Store must be defined to get permissions')
-  }
-
-  async getPermissions(): Promise<InvokerPermission[]> {
-    return await this.store.getPermissions()
-  }
-
-  // assumed the permissions are always granted
-  async requestPermissions(permissions: PermissionRequest[]): Promise<RequestedPermission[]> {
-    await Promise.resolve()
-    // Flatten PermissionRequest[] into InvokerPermission[]
-    const newPermissions: InvokerPermission[] = []
-    const now = Date.now()
-    for (const req of permissions) {
-      for (const parentCapability in req) {
-        newPermissions.push({
-          invoker: this.invoker,
-          parentCapability,
-          caveats: Object.entries(req[parentCapability]).map(([type, value]) => ({ type: type as CaveatTypes, value })),
-          date: now,
-        })
-      }
-    }
-
-    // Update or add permissions in the store
-    const existingPermissions = await this.getPermissions()
-    for (const perm of newPermissions) {
-      const idx = existingPermissions.findIndex(
-        p => p.invoker === perm.invoker && p.parentCapability === perm.parentCapability,
-      )
-      if (idx === -1) {
-        existingPermissions.push(perm)
-      } else {
-        existingPermissions[idx] = perm
-      }
-    }
-    await this.store.setPermissions(existingPermissions)
-
-    // Return the granted permissions in RequestedPermission shape
-    return newPermissions.map(({ parentCapability, date }) => ({ parentCapability, date }))
-  }
-
-  // Assumes the permissions are always revoked
-  async revokePermissions(permissions: PermissionRequest): Promise<RequestedPermission[]> {
-    const existingPermissions = await this.getPermissions()
-    const revoked: RequestedPermission[] = []
-    for (const parentCapability in permissions) {
-      const idx = existingPermissions.findIndex(
-        p => p.invoker === this.invoker && p.parentCapability === parentCapability,
-      )
-      if (idx !== -1) {
-        const removed = existingPermissions.splice(idx, 1)[0]
-        revoked.push({ parentCapability: removed.parentCapability, date: removed.date })
-      }
-    }
-    await this.store.setPermissions(existingPermissions)
-    return revoked
-  }
-}

package/src/simple/permissions/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleXyoPermissions.ts'
-export * from './store/index.ts'

package/src/simple/permissions/store/MemoryPermissions.ts

@@ -1,32 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { InvokerPermission } from '@xyo-network/xl1-protocol-lib'
-
-import type { Invoker, PermissionsStore } from './PermissionsStore.ts'
-
-/**
- * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
- * Does not persist data beyond the lifetime of the instance.
- * Assumes all permission requests are granted and revocations always succeed.
- */
-export class MemoryPermissionsStore implements PermissionsStore {
-  private _invoker: Invoker
-  private permissions: InvokerPermission[] = []
-
-  constructor(invoker: Invoker) {
-    this._invoker = invoker
-  }
-
-  get invoker(): Invoker {
-    return assertEx(this._invoker, () => 'Invoker must be defined to get permissions')
-  }
-
-  async getPermissions(): Promise<InvokerPermission[]> {
-    await Promise.resolve()
-    return this.permissions
-  }
-
-  async setPermissions(permissions: InvokerPermission[]): Promise<void> {
-    await Promise.resolve()
-    this.permissions = permissions
-  }
-}

package/src/simple/permissions/store/PermissionsStore.ts

@@ -1,17 +0,0 @@
-import type { InvokerPermission, PermissionsGetHandler } from '@xyo-network/xl1-protocol-lib'
-
-/** Invoker type. */
-export type Invoker = string
-/** ParentCapability type. */
-export type ParentCapability = string
-/**
- * Interface for a permissions store that abstracts away the storage medium.
- * (i.e. in-memory, browser storage, database, etc.)
- */
-export interface PermissionsStore extends PermissionsGetHandler {
-  // The invoker associated with this permissions store
-  readonly invoker: Invoker
-  // Retrieve all permissions associated with the invoker.
-  // Store or update permissions for the invoker
-  setPermissions(permissions: InvokerPermission[]): Promise<void>
-}

package/src/simple/permissions/store/index.ts

@@ -1,2 +0,0 @@
-export * from './MemoryPermissions.ts'
-export * from './PermissionsStore.ts'

package/src/simple/runner/SimpleXyoRunner.ts

@@ -1,41 +0,0 @@
-import { type Hash } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  MempoolRunner,
-  MempoolRunnerMoniker, SignedHydratedTransactionWithStorageMeta,
-  XyoRunner, XyoRunnerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleXyoRunner. */
-export interface SimpleXyoRunnerParams extends CreatableProviderParams {
-}
-
-/** SimpleXyoRunner implementation. */
-@creatableProvider()
-export class SimpleXyoRunner extends AbstractCreatableProvider<SimpleXyoRunnerParams> implements XyoRunner {
-  static readonly defaultMoniker = XyoRunnerMoniker
-  static readonly dependencies = [MempoolRunnerMoniker]
-  static readonly monikers = [XyoRunnerMoniker]
-  moniker = SimpleXyoRunner.defaultMoniker
-
-  private _mempoolRunner?: MempoolRunner
-
-  get mempool() {
-    return this._mempoolRunner!
-  }
-
-  async broadcastTransaction(transaction: SignedHydratedTransactionWithStorageMeta): Promise<Hash> {
-    await this.mempool.submitTransactions([transaction])
-    const hash = await PayloadBuilder.hash(transaction[0])
-    this.logger?.info(`Broadcasted transaction with hash ${hash}`)
-    return hash
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._mempoolRunner = await this.locator.getInstance<MempoolRunner>(MempoolRunnerMoniker)
-  }
-}

package/src/simple/runner/index.ts

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

package/src/simple/signer/SimpleXyoSigner.ts

@@ -1,78 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import type { AccountInstance, Payload } from '@xyo-network/sdk-js'
-import { Account, PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, ChainId, SignedHydratedTransactionWithHashMeta,
-  SignedTransactionBoundWitness, TransactionFeesBigInt,
-  UnsignedTransactionBoundWitness,
-  XL1BlockNumber, XyoSigner,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  SignedHydratedTransactionWithHashMetaZod,
-  XyoSignerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
-import { buildTransaction, signTransaction } from '../../transaction/index.ts'
-
-/** Parameters for SimpleXyoSigner. */
-export interface SimpleXyoSignerParams extends CreatableProviderParams {
-  account: AccountInstance
-}
-
-/** SimpleXyoSigner implementation. */
-export class SimpleXyoSigner extends AbstractCreatableProvider<SimpleXyoSignerParams> implements XyoSigner {
-  static readonly defaultMoniker = XyoSignerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [XyoSignerMoniker]
-  moniker = SimpleXyoSigner.defaultMoniker
-
-  static override async paramsHandler(params?: Partial<SimpleXyoSignerParams>) {
-    let account: AccountInstance
-    if (params?.account) {
-      account = params.account
-    } else {
-      const localLogger = params?.logger ?? params?.context?.logger
-      localLogger?.warn(`No account provided to SimpleXyoSigner, generating a random account. 
-        This account will not be persisted and any transactions signed with it may be lost.
-      `)
-
-      account = await Account.random()
-    }
-    return { ...await super.paramsHandler(params), account }
-  }
-
-  address(): Promisable<Address> {
-    return this.params.account.address
-  }
-
-  /** @deprecated - use signTransaction instead */
-  async createSignedTransaction(
-    chain: ChainId,
-    elevatedPayloads: AllowedBlockPayload[],
-    additionalPayloads: Payload[],
-    nbf: XL1BlockNumber,
-    exp: XL1BlockNumber,
-    fees: TransactionFeesBigInt,
-    from?: Address,
-  ): Promise<SignedTransactionBoundWitness> {
-    const fromAddress = from ?? await this.address()
-    const transaction = await buildTransaction(
-      chain,
-      elevatedPayloads,
-      additionalPayloads,
-      this.params.account,
-      nbf,
-      exp,
-      fromAddress,
-      fees,
-    )
-    return transaction[0]
-  }
-
-  async signTransaction(tx: [UnsignedTransactionBoundWitness, Payload[]]): Promise<SignedHydratedTransactionWithHashMeta> {
-    const txBW = await signTransaction(tx[0], this.params.account)
-    return SignedHydratedTransactionWithHashMetaZod.parse([await PayloadBuilder.addStorageMeta(txBW), await PayloadBuilder.addStorageMeta(tx[1])])
-  }
-}

package/src/simple/signer/index.ts

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