@xyo-network/xl1-protocol-sdk 1.16.0 → 1.16.2

package/src/provider/XyoGatewayRunner.ts

@@ -0,0 +1,42 @@
+import type {
+  Address, Hash, Hex,
+} from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
+import type { Payload } from '@xyo-network/payload-model'
+import type {
+  AllowedBlockPayload, AttoXL1, SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta, TransactionFeesBigInt,
+  UnsignedHydratedTransaction,
+} from '@xyo-network/xl1-protocol'
+
+import type { DataLakeRunner } from './DataLake.ts'
+import type { XyoGateway } from './XyoGateway.ts'
+
+export interface TransactionOptions {
+  chain?: Hex
+  exp?: number
+  fees?: TransactionFeesBigInt
+  from?: Address
+  nbf?: number
+}
+
+export interface XyoGatewayRunnerMethods {
+
+  addPayloadsToChain(
+    onChain: AllowedBlockPayload[],
+    offChain: Payload[],
+    options?: TransactionOptions
+  ): Promisable<[Hash, SignedHydratedTransactionWithHashMeta]>
+
+  addTransactionToChain(
+    tx: UnsignedHydratedTransaction | SignedHydratedTransaction,
+  ): Promisable<[Hash, SignedHydratedTransactionWithHashMeta]>
+
+  send(to: Address, amount: AttoXL1, options?: TransactionOptions): Promisable<Hash>
+  sendMany(transfers: Record<Address, AttoXL1>, options?: TransactionOptions): Promisable<Hash>
+}
+
+export interface XyoGatewayRunner extends XyoGatewayRunnerMethods, XyoGateway {
+  dataLakes: DataLakeRunner[]
+  addDataLake(dataLake: DataLakeRunner): number
+  removeDataLake(index: number): void
+}

package/src/provider/index.ts

@@ -1,12 +1,12 @@
+export * from './DataLake.ts'
 export * from './permissions/index.ts'
+export * from './signer/index.ts'
 export * from './TransactionSubmitter.ts'
+export * from './viewer/index.ts'
 export * from './XyoClient.ts'
 export * from './XyoConnection.ts'
-export * from './XyoDataLake.ts'
 export * from './XyoGateway.ts'
-export * from './XyoGatewayHelpers.ts'
+export * from './XyoGatewayRunner.ts'
 export * from './XyoNetwork.ts'
 export * from './XyoRunner.ts'
-export * from './XyoSigner.ts'
-export * from './XyoViewer.ts'
 export * from './XyoWallet.ts'

package/src/provider/{XyoSigner.ts → signer/XyoSigner.ts}

@@ -3,7 +3,7 @@ import type { Promisable } from '@xylabs/promise'
 import type { Signed, UnsignedBoundWitness } from '@xyo-network/boundwitness-model'
 import type { Payload } from '@xyo-network/payload-model'
 import type {
-  AllowedBlockPayload, ChainId, TransactionBoundWitness,
+  AllowedBlockPayload, ChainId, SignedHydratedTransactionWithHashMeta, TransactionBoundWitness,
   TransactionFeesBigInt,
 } from '@xyo-network/xl1-protocol'
 
@@ -12,7 +12,7 @@ export interface XyoSigner {
   // 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: [UnsignedBoundWitness<TransactionBoundWitness>, Payload[]]): Promisable<[Signed<TransactionBoundWitness>, Payload[]]>
+  signTransaction(tx: [UnsignedBoundWitness<TransactionBoundWitness>, Payload[]]): Promisable<SignedHydratedTransactionWithHashMeta>
 }
 
 export interface XyoSignerDeprecated {

package/src/provider/signer/index.ts

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

package/src/{interfaces/viewers/NetworkStakeViewer → provider/viewer/NetworkStake}/NetworkStakeViewer.ts

@@ -1,6 +1,6 @@
 import type { Promisable } from '@xylabs/promise'
 
-import type { StepRewardsViewer } from './StepRewardsViewer.ts'
+import type { NetworkStakeStepRewardsViewer } from './Rewards/index.ts'
 
 export interface NetworkStakeViewerMethods {
   /** @returns the active stake and the number of active validators [active, block] */
@@ -8,5 +8,5 @@ export interface NetworkStakeViewerMethods {
 }
 
 export interface NetworkStakeViewer extends NetworkStakeViewerMethods {
-  stepRewards?: StepRewardsViewer
+  stepRewards?: NetworkStakeStepRewardsViewer
 }

package/src/provider/viewer/NetworkStake/Rewards/ByPositionViewer.ts

@@ -0,0 +1,9 @@
+import type { NetworkStakeStepRewardsByPositionViewerOptions } from './Options.ts'
+import type { NetworkStakeStepRewardsByIndexViewerMethodsTemplate } from './templates/index.ts'
+
+// Note: Viewers are client objects that can nest other viewers and ViewerMethods objects consist only of methods that return data.
+
+export interface NetworkStakeStepRewardsByPositionViewerMethods extends
+  NetworkStakeStepRewardsByIndexViewerMethodsTemplate<NetworkStakeStepRewardsByPositionViewerOptions, number> {}
+
+export interface NetworkStakeStepRewardsByPositionViewer extends NetworkStakeStepRewardsByPositionViewerMethods {}

package/src/provider/viewer/NetworkStake/Rewards/ByStakerViewer.ts

@@ -0,0 +1,10 @@
+import type { Address } from '@xylabs/hex'
+
+import type { NetworkStakeStepRewardsByStakerViewerOptions } from './Options.ts'
+import type { NetworkStakeStepRewardsByIndexViewerMethodsTemplate } from './templates/index.ts'
+
+// Note: Viewers are client objects that can nest other viewers and ViewerMethods objects consist only of methods that return data.
+
+export interface NetworkStakeStepRewardsByStakerViewerMethods
+  extends NetworkStakeStepRewardsByIndexViewerMethodsTemplate<NetworkStakeStepRewardsByStakerViewerOptions, Address> {}
+export interface NetworkStakeStepRewardsByStakerViewer extends NetworkStakeStepRewardsByStakerViewerMethods {}

package/src/provider/viewer/NetworkStake/Rewards/ByStepViewer.ts

@@ -0,0 +1,10 @@
+import type { StepIdentityString } from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakeStepRewardsByStepViewerOptions } from './Options.ts'
+import type { NetworkStakeStepRewardsByIndexViewerMethodsTemplate } from './templates/index.ts'
+
+// Note: Viewers are client objects that can nest other viewers and ViewerMethods objects consist only of methods that return data.
+
+export interface NetworkStakeStepRewardsByStepViewerMethods extends
+  NetworkStakeStepRewardsByIndexViewerMethodsTemplate<NetworkStakeStepRewardsByStepViewerOptions, StepIdentityString> {}
+export interface NetworkStakeStepRewardsByStepViewer extends NetworkStakeStepRewardsByStepViewerMethods {}

package/src/provider/viewer/NetworkStake/Rewards/Options.ts

@@ -0,0 +1,18 @@
+import type { Address } from '@xylabs/hex'
+import type { BlockRange, StepIdentity } from '@xyo-network/xl1-protocol'
+
+export interface NetworkStakeStepRewardsRangeOptions {
+  range?: BlockRange
+}
+
+export interface NetworkStakeStepRewardsByStepViewerOptions extends NetworkStakeStepRewardsRangeOptions {
+  steps?: StepIdentity[]
+}
+
+export interface NetworkStakeStepRewardsByStakerViewerOptions extends NetworkStakeStepRewardsRangeOptions {
+  stakers?: Address[]
+}
+
+export interface NetworkStakeStepRewardsByPositionViewerOptions extends NetworkStakeStepRewardsRangeOptions {
+  positions?: number[]
+}

package/src/provider/viewer/NetworkStake/Rewards/TotalViewer.ts

@@ -0,0 +1,9 @@
+import type { AttoXL1 } from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakeStepRewardsRangeOptions } from './Options.ts'
+import type { NetworkStakeStepRewardsViewerMethodsTemplate } from './templates/index.ts'
+
+// Note: Viewers are client objects that can nest other viewers and ViewerMethods objects consist only of methods that return data.
+
+export interface NetworkStakeStepRewardsTotalViewerMethods extends NetworkStakeStepRewardsViewerMethodsTemplate<NetworkStakeStepRewardsRangeOptions, AttoXL1> {}
+export interface NetworkStakeStepRewardsTotalViewer extends NetworkStakeStepRewardsTotalViewerMethods {}

package/src/provider/viewer/NetworkStake/Rewards/Viewer.ts

@@ -0,0 +1,13 @@
+import type { NetworkStakeStepRewardsByPositionViewer } from './ByPositionViewer.ts'
+import type { NetworkStakeStepRewardsByStakerViewer } from './ByStakerViewer.ts'
+import type { NetworkStakeStepRewardsByStepViewer } from './ByStepViewer.ts'
+import type { NetworkStakeStepRewardsTotalViewer } from './TotalViewer.ts'
+
+export interface NetworkStakeStepRewardsViewerMethods {}
+
+export interface NetworkStakeStepRewardsViewer extends NetworkStakeStepRewardsViewerMethods {
+  position?: NetworkStakeStepRewardsByPositionViewer
+  staker?: NetworkStakeStepRewardsByStakerViewer
+  step?: NetworkStakeStepRewardsByStepViewer
+  total?: NetworkStakeStepRewardsTotalViewer
+}

package/src/provider/viewer/NetworkStake/Rewards/index.ts

@@ -0,0 +1,7 @@
+export * from './ByPositionViewer.ts'
+export * from './ByStakerViewer.ts'
+export * from './ByStepViewer.ts'
+export * from './Options.ts'
+export * from './templates/index.ts'
+export * from './TotalViewer.ts'
+export * from './Viewer.ts'

package/src/provider/viewer/NetworkStake/Rewards/templates/ByIndexMethodsTemplate.ts

@@ -0,0 +1,7 @@
+import type { AttoXL1 } from '@xyo-network/xl1-protocol'
+
+import type { RecordKeyType } from '../../../../../model/index.ts'
+import type { NetworkStakeStepRewardsViewerMethodsTemplate } from './MethodsTemplate.ts'
+
+export interface NetworkStakeStepRewardsByIndexViewerMethodsTemplate<TOptions, TResultIndex extends RecordKeyType>
+  extends NetworkStakeStepRewardsViewerMethodsTemplate<TOptions, Record<TResultIndex, AttoXL1>> {}

package/src/{interfaces/viewers/NetworkStakeViewer/RewardsViewerMethodsTemplate.ts → provider/viewer/NetworkStake/Rewards/templates/MethodsTemplate.ts}

@@ -1,6 +1,6 @@
 import type { Promisable } from '@xylabs/promise'
 
-export interface RewardsViewerMethodsTemplate<TOptions, TResult> {
+export interface NetworkStakeStepRewardsViewerMethodsTemplate<TOptions, TResult> {
   bonus(options?: TOptions): Promisable<TResult>
   claimed(options?: TOptions): Promisable<TResult>
   earned(options?: TOptions): Promisable<TResult>

package/src/provider/viewer/NetworkStake/Rewards/templates/index.ts

@@ -0,0 +1,2 @@
+export * from './ByIndexMethodsTemplate.ts'
+export * from './MethodsTemplate.ts'

package/src/provider/viewer/NetworkStake/index.ts

@@ -0,0 +1,4 @@
+export * from './NetworkStakeViewer.ts'
+export * from './Rewards/index.ts'
+
+// Note: Viewers are client objects that can nest other viewers and ViewerMethods objects consist only of methods that return data.

package/src/{interfaces/viewers/NetworkStakeViewer → provider/viewer}/StepViewer.ts

@@ -2,7 +2,8 @@ import type { Address } from '@xylabs/hex'
 import type { Promisable } from '@xylabs/promise'
 import type { PositionId, StepIdentity } from '@xyo-network/xl1-protocol'
 
-import type { Position } from '../Stake.ts'
+import type { Position } from '../../interfaces/index.ts'
+import type { NetworkStakeStepRewardsViewer } from './NetworkStake/index.ts'
 
 export interface PagedPositionsOptions {
   cursor?: PositionId
@@ -37,6 +38,10 @@ export interface StepViewerMethods {
 
   stakers(step: StepIdentity, options?: PagedStakersOptions): Promisable<Address[]>
 
-  // total weight of all stakers during a given step
-  weight(step: StepIdentity): Promisable<bigint>
+  // if no positionId is supplied, returns the total stake weight for the step
+  weight(step: StepIdentity, positionId?: PositionId): Promisable<bigint>
+}
+
+export interface StepViewer extends StepViewerMethods {
+  rewards?: NetworkStakeStepRewardsViewer
 }

package/src/provider/{XyoViewer.ts → viewer/XyoViewer.ts}

@@ -2,10 +2,11 @@ import type {
   AccountBalanceViewInterface, BlockViewInterface, ChainViewInterface,
   ForkViewer,
   NetworkStakeStepRewardViewInterface,
-  NetworkStakeViewer,
   StakeViewer,
   TransactionViewInterface, TransferBalanceViewInterface,
-} from '../interfaces/index.ts'
+} from '../../interfaces/index.ts'
+import type { NetworkStakeViewer } from './NetworkStake/index.ts'
+import type { StepViewer } from './StepViewer.ts'
 
 export interface XyoViewerMethods extends AccountBalanceViewInterface, TransferBalanceViewInterface,
   NetworkStakeStepRewardViewInterface,
@@ -13,5 +14,6 @@ export interface XyoViewerMethods extends AccountBalanceViewInterface, TransferB
 }
 
 export interface XyoViewer extends XyoViewerMethods {
-  networkStakeViewer?: NetworkStakeViewer
+  networkStake?: NetworkStakeViewer
+  step?: StepViewer
 }

package/src/provider/viewer/index.ts

@@ -0,0 +1,3 @@
+export * from './NetworkStake/index.ts'
+export * from './StepViewer.ts'
+export * from './XyoViewer.ts'

package/src/simple/client/SimpleXyoClient.ts

@@ -0,0 +1,13 @@
+import type {
+  XyoClient, XyoGateway, XyoPermissions,
+} from '../../provider/index.ts'
+
+export class SimpleXyoClient implements XyoClient {
+  gateways: Readonly<Record<string, XyoGateway>>
+  permissions: XyoPermissions
+
+  constructor(gateways: Readonly<Record<string, XyoGateway>>, permissions: XyoPermissions) {
+    this.gateways = gateways
+    this.permissions = permissions
+  }
+}

package/src/simple/client/index.ts

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

package/src/simple/datalake/SimpleDataLakeRunner.ts

@@ -0,0 +1,36 @@
+import type { Hash } from '@xylabs/hex'
+
+import type { MapType } from '../../map/index.ts'
+import type {
+  DataLakeData,
+  DataLakeRunner,
+} from '../../provider/index.ts'
+import type { DataLakeViewerParams } from './SimpleDataLakeViewer.ts'
+import { SimpleDataLakeViewer } from './SimpleDataLakeViewer.ts'
+
+export interface DataLakeRunnerParams extends DataLakeViewerParams<MapType<Hash, DataLakeData>> {}
+
+export class SimpleDataLakeRunner<TParams extends DataLakeRunnerParams> extends SimpleDataLakeViewer<MapType<Hash, DataLakeData>> implements DataLakeRunner {
+  constructor(params: TParams) {
+    super(params)
+  }
+
+  async clear(): Promise<void> {
+    await this.map.clear()
+  }
+
+  async delete(hash: Hash): Promise<boolean> {
+    return await this.map.delete(hash)
+  }
+
+  async set(hash: Hash, data: DataLakeData): Promise<void> {
+    if (this.isAllowed(data)) {
+      await this.map.set(hash, data)
+    }
+  }
+
+  async setMany(entries: [Hash, DataLakeData][]): Promise<void> {
+    const allowed = entries.filter(([_, data]) => this.isAllowed(data))
+    return await this.map.setMany(allowed)
+  }
+}

package/src/simple/datalake/SimpleDataLakeViewer.ts

@@ -0,0 +1,74 @@
+import type { Hash } from '@xylabs/hex'
+import { isAnyPayload, type Schema } from '@xyo-network/payload-model'
+
+import type { MapTypeRead } from '../../map/index.ts'
+import type {
+  DataLakeData,
+  DataLakeViewer,
+} from '../../provider/index.ts'
+
+export interface DataLakeViewerParams<TMap extends MapTypeRead<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData>> {
+  allowedSchemas?: Schema[]
+  disallowedSchemas?: Schema[]
+  map: TMap
+}
+
+export class SimpleDataLakeViewer<TMap extends MapTypeRead<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData>,
+  TParams extends DataLakeViewerParams<TMap> = DataLakeViewerParams<TMap>> implements DataLakeViewer {
+  private readonly _params: TParams
+
+  constructor(params: TParams) {
+    this._params = params
+  }
+
+  get allowedSchemas(): Schema[] | undefined {
+    return this._params.allowedSchemas
+  }
+
+  get disallowedSchemas(): Schema[] | undefined {
+    return this._params.disallowedSchemas
+  }
+
+  protected get map(): TMap {
+    return this._params.map
+  }
+
+  protected get params() {
+    return this._params
+  }
+
+  async get(hash: Hash): Promise<DataLakeData | undefined> {
+    const result = await this.map.get(hash)
+    return this.isAllowed(result) ? result : undefined
+  }
+
+  async getMany(hashes: Hash[]): Promise<DataLakeData[]> {
+    const result = await this.map.getMany(hashes)
+    return result.filter(data => this.isAllowed(data))
+  }
+
+  async has(hash: Hash): Promise<boolean> {
+    const value = await this.get(hash)
+    if (isAnyPayload(value)) {
+      return this.isAllowed(value)
+    }
+    return value !== undefined
+  }
+
+  protected isAllowed(value: DataLakeData | undefined): boolean {
+    if (isAnyPayload(value)) {
+      return this.isAllowedSchema(value.schema)
+    }
+    return true
+  }
+
+  protected isAllowedSchema(schema: Schema): boolean {
+    if (this.allowedSchemas && !this.allowedSchemas.includes(schema)) {
+      return false
+    }
+    if (this.disallowedSchemas && this.disallowedSchemas.includes(schema)) {
+      return false
+    }
+    return true
+  }
+}

package/src/simple/datalake/index.ts

@@ -0,0 +1,2 @@
+export * from './SimpleDataLakeRunner.ts'
+export * from './SimpleDataLakeViewer.ts'

package/src/simple/gateway/SimpleXyoGateway.ts

@@ -0,0 +1,21 @@
+import type {
+  XyoConnection, XyoGateway, XyoSigner,
+} from '../../provider/index.ts'
+
+export class SimpleXyoGateway implements XyoGateway {
+  private readonly _connection: XyoConnection
+  private readonly _signer: XyoSigner
+
+  constructor(signer: XyoSigner, connection: XyoConnection) {
+    this._signer = signer
+    this._connection = connection
+  }
+
+  get connection(): XyoConnection {
+    return this._connection
+  }
+
+  get signer(): XyoSigner {
+    return this._signer
+  }
+}

package/src/simple/gateway/SimpleXyoGatewayRunner.ts

@@ -0,0 +1,116 @@
+import { assertEx } from '@xylabs/assert'
+import type {
+  Address, Hash, Hex,
+} from '@xylabs/hex'
+import { BigIntToJsonZod } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
+import {
+  type AllowedBlockPayload,
+  type AttoXL1,
+  type SignedHydratedTransaction,
+  type SignedHydratedTransactionWithHashMeta,
+  type Transfer,
+  TransferSchema,
+} from '@xyo-network/xl1-protocol'
+
+import type {
+  DataLakeRunner,
+  TransactionOptions,
+  XyoConnection, XyoGateway, XyoGatewayRunner,
+  XyoSigner,
+} from '../../provider/index.ts'
+import { buildUnsignedTransaction } from '../../transaction/index.ts'
+
+export class SimpleXyoGatewayRunner implements XyoGatewayRunner {
+  protected readonly gateway: XyoGateway
+  private _dataLakes: (DataLakeRunner | null)[]
+
+  constructor(gateway: XyoGateway, dataLakes: DataLakeRunner[] = []) {
+    this.gateway = gateway
+    this._dataLakes = [...dataLakes]
+  }
+
+  get connection(): XyoConnection {
+    return this.gateway.connection
+  }
+
+  get dataLakes(): DataLakeRunner[] {
+    throw new Error('Method not implemented.')
+  }
+
+  get signer(): XyoSigner {
+    return this.gateway.signer
+  }
+
+  addDataLake(dataLake: DataLakeRunner): number {
+    this._dataLakes.push(dataLake)
+    return this._dataLakes.length - 1
+  }
+
+  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 = isDefined(nbf) ? nbf : await viewer?.currentBlockNumber()
+    const resolvedExp = isDefined(exp) ? exp : resolvedNbf + 10
+
+    // 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)
+  }
+
+  async addTransactionToChain(tx: SignedHydratedTransaction): Promise<[Hash, SignedHydratedTransactionWithHashMeta]> {
+    const connection = this.gateway.connection
+    const signer = this.gateway.signer
+    const runner = assertEx(connection.runner, () => 'No runner available on connection')
+    const signedTx = await signer.signTransaction(tx)
+    await this.addPayloadsToDataLakes(signedTx[1])
+    return [await runner.broadcastTransaction(
+      [await PayloadBuilder.addStorageMeta(signedTx[0]),
+        await PayloadBuilder.addStorageMeta(signedTx[1])],
+    ), signedTx]
+  }
+
+  removeDataLake(index: number): void {
+    this._dataLakes[index] = null
+  }
+
+  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
+  }
+
+  protected async addPayloadsToDataLakes(payloads: WithHashMeta<Payload>[]): Promise<void> {
+    await Promise.all(this._dataLakes.map(async (dataLake) => {
+      await Promise.all(payloads.map(async (payload) => {
+        await dataLake?.set(payload._hash, payload)
+      }))
+    }))
+  }
+}

package/src/simple/gateway/index.ts

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

package/src/simple/index.ts

@@ -0,0 +1,7 @@
+export * from './client/index.ts'
+export * from './datalake/index.ts'
+export * from './gateway/index.ts'
+export * from './network/index.ts'
+export * from './permissions/index.ts'
+export * from './runner/index.ts'
+export * from './signer/index.ts'

package/src/simple/network/SimpleXyoNetwork.ts

@@ -0,0 +1,48 @@
+import { isUndefined } from '@xylabs/typeof'
+import type {
+  GatewayName,
+  NetworkStatus,
+} from '@xyo-network/xl1-protocol'
+import { isNetworkStatus } from '@xyo-network/xl1-protocol'
+import axios from 'axios'
+
+import type { XyoNetwork } from '../../provider/index.ts'
+import {
+  errorStatus, StatusNetworks, unknownStatus,
+} from './lib/index.ts'
+
+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

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

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

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

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

@@ -0,0 +1,27 @@
+import type { GatewayName } from '@xyo-network/xl1-protocol'
+
+export type StatusNetwork = {
+  id: GatewayName
+  statusUrl: string
+}
+
+export const MainNetworkStats: StatusNetwork = {
+  id: 'mainnet' as GatewayName,
+  statusUrl: 'https://xyo.network/chain-network-status-mainnet.json',
+}
+
+export const SequenceNetworkStats: StatusNetwork = {
+  id: 'sequence' as GatewayName,
+  statusUrl: 'https://beta.xyo.network/chain-network-status-sequence.json',
+}
+
+export const LocalNetworkStats: StatusNetwork = {
+  id: 'local' as GatewayName,
+  statusUrl: 'http://localhost:3002/chain-network-status-local.json',
+}
+
+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

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