@xyo-network/react-chain-network 1.6.0 → 1.6.2

package/src/models/Bootstrap.ts

@@ -1,51 +0,0 @@
-import type { Address } from '@xylabs/hex'
-import { AsObjectFactory } from '@xylabs/object'
-import type { Payload } from '@xyo-network/payload-model'
-import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
-import type { NetworkId } from '@xyo-network/xl1-protocol'
-
-export const NetworkBootstrapSchema = 'network.xyo.network.bootstrap' as const
-export type NetworkBootstrapSchema = typeof NetworkBootstrapSchema
-
-export interface ChainForkFields {
-  /** Block Number at which the chain was forked from */
-  forkedAtLastBlockNumber?: string
-  /** Hash in the last block the chain was forked from */
-  forkedAtLastHash?: string
-  /** Address of the forked chain */
-  forkedChainId?: Address
-}
-
-export interface NetworkFields {
-  /** Description of the network */
-  description: string
-  /** Url for accessing the network explorer */
-  explorerUrl?: string
-  /** string representation of the icon (svg) */
-  icon?: string
-  /** Machine-readable identifier */
-  id: NetworkId
-  /** Human-readable identifier */
-  name: string
-  schema: NetworkBootstrapSchema
-  /** Symbol of the network */
-  symbol?: string
-  /** Url for accessing the network */
-  url: string
-}
-
-/** Note: Optional Properties can be found walking the chain to the genesis block */
-export interface NetworkBootstrapFields extends NetworkFields, ChainForkFields {
-  /** Address of the chain, i.e. smart contract address */
-  chainId?: Address
-}
-
-export interface Network extends NetworkBootstrap {
-  custom: boolean
-}
-
-export type NetworkBootstrap = Payload<NetworkBootstrapFields, NetworkBootstrapSchema>
-
-export const isNetworkBootstrap = isPayloadOfSchemaType<NetworkBootstrap>(NetworkBootstrapSchema)
-
-export const asOptionalNetwork = AsObjectFactory.createOptional(isNetworkBootstrap)

package/src/models/index.ts

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

package/src/provider/NetworkProvider.ts

@@ -1,176 +0,0 @@
-/* eslint-disable sonarjs/deprecation */
-import { assertEx } from '@xylabs/assert'
-import type { Address, Hash } from '@xylabs/hex'
-import type { Promisable } from '@xylabs/promise'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import type { Signed } from '@xyo-network/boundwitness-model'
-import type { BridgeInstance } from '@xyo-network/bridge-model'
-import { initBridge } from '@xyo-network/chain-orchestration'
-import { findMostRecentBlock } from '@xyo-network/chain-protocol'
-import { ChainBlockNumberIterationService } from '@xyo-network/chain-services'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-import type {
-  AllowedBlockPayload,
-  BlockBoundWitness,
-  HydratedBlock, HydratedTransaction, TransactionBoundWitness,
-  TransactionFeesBigInt,
-  Transfer,
-  XyoRunner,
-  XyoSigner,
-  XyoViewer,
-  XyoWallet,
-} from '@xyo-network/xl1-protocol'
-import { hydrateBlock } from '@xyo-network/xl1-protocol-sdk'
-
-export const FINALIZED_ARCHIVIST = 'XYOChain:Chain:Finalized' as const
-
-export interface NetworkProviderParams {
-  chainId?: Address
-  network: string
-}
-
-// TODO: change back to implementing XyoProvider which requires sub objects
-/**
- * @deprecated Use MemoryXyoProvider instead
- */
-export class NetworkProvider implements XyoSigner, XyoViewer, XyoWallet, XyoRunner {
-  private _bridge: BridgeInstance
-
-  constructor(bridge: BridgeInstance) {
-    this._bridge = bridge
-  }
-
-  private get bridge() {
-    return assertEx(this._bridge, () => 'Bridge not set')
-  }
-
-  static async create({ network }: NetworkProviderParams): Promise<NetworkProvider> {
-    const bridge = await initBridge(network)
-    return new NetworkProvider(bridge)
-  }
-
-  accountBalance(_address: Address): Promisable<bigint> {
-    throw new Error('Method not implemented.')
-  }
-
-  accountHistory(_address: Address): Promisable<[TransactionBoundWitness[], Transfer[]]> {
-    throw new Error('Method not implemented.')
-  }
-
-  accounts(): Promisable<Address[]> {
-    throw new Error('Method not implemented.')
-  }
-
-  addChain(_chain: Address, _name?: string): Promisable<object> {
-    throw new Error('Method not implemented.')
-  }
-
-  address(): Promisable<Address> {
-    throw new Error('Method not implemented.')
-  }
-
-  blockByHash(_hash: Hash): Promisable<HydratedBlock | null> {
-    throw new Error('Method not implemented.')
-  }
-
-  blockByNumber(_blockNumber: number): Promisable<HydratedBlock | null> {
-    throw new Error('Method not implemented.')
-  }
-
-  blocksByHash(_hash: Hash, _limit?: number): Promisable<HydratedBlock[]> {
-    throw new Error('Method not implemented.')
-  }
-
-  broadcastTransaction(_transaction: HydratedTransaction): Promisable<Hash> {
-    throw new Error('Method not implemented.')
-  }
-
-  chain(): Promisable<Address> {
-    throw new Error('Method not implemented.')
-  }
-
-  chainId(): Promisable<Address> {
-    throw new Error('Method not implemented.')
-  }
-
-  chains(): Promisable<object> {
-    throw new Error('Method not implemented.')
-  }
-
-  createSignedTransaction(
-    _chain: Address,
-    _elevatedPayloads: AllowedBlockPayload[],
-    _additionalPayloads: Payload[],
-    _nbf: number,
-    _exp: number,
-    _fees: TransactionFeesBigInt,
-    _from?: Address,
-  ): Promisable<Signed<TransactionBoundWitness>> {
-    throw new Error('Method not implemented.')
-  }
-
-  currentBlock(): Promisable<HydratedBlock> {
-    throw new Error('Method not implemented.')
-  }
-
-  currentBlockHash(): Promisable<Hash> {
-    throw new Error('Method not implemented.')
-  }
-
-  currentBlockNumber(): Promisable<number> {
-    throw new Error('Method not implemented.')
-  }
-
-  permissions(): Promisable<Record<string, object>> {
-    throw new Error('Method not implemented.')
-  }
-
-  async previousBlocks(startingBlock?: Hash, count = 25): Promise<HydratedBlock[]> {
-    const chainArchivist = await this.getFinalizedArchivist()
-    const head: BlockBoundWitness = assertEx(await findMostRecentBlock(chainArchivist, { cursor: startingBlock }), () => 'Unable to find most recent block')
-    const iterator = await ChainBlockNumberIterationService.create({ chainArchivist, head })
-    const blocks = await iterator.previous(head.block, count)
-
-    let hydratedBlocks: HydratedBlock[] = []
-    for (const block of blocks) {
-      hydratedBlocks.push(await hydrateBlock(chainArchivist, await PayloadBuilder.hash(block)))
-    }
-    return hydratedBlocks
-  }
-
-  requestPermissions(_permissions: object): Promisable<object> {
-    throw new Error('Method not implemented.')
-  }
-
-  revokePermissions(_permissions: object): Promisable<object> {
-    throw new Error('Method not implemented.')
-  }
-
-  signTransaction(_transaction: TransactionBoundWitness): Promisable<Signed<TransactionBoundWitness>> {
-    throw new Error('Method not implemented.')
-  }
-
-  switchChain(_chain: Address): Promisable<void> {
-    throw new Error('Method not implemented.')
-  }
-
-  transactionByBlockHashAndIndex(_blockHash: Hash, _transactionIndex: number): Promisable<HydratedTransaction | null> {
-    throw new Error('Method not implemented.')
-  }
-
-  transactionByBlockNumberAndIndex(_blockNumber: number, _transactionIndex: number): Promisable<HydratedTransaction | null> {
-    throw new Error('Method not implemented.')
-  }
-
-  transactionByHash(_transactionHash: Hash): Promisable<HydratedTransaction | null> {
-    throw new Error('Method not implemented.')
-  }
-
-  private async getFinalizedArchivist(): Promise<ArchivistInstance> {
-    const bridge = this.bridge
-    const mod = assertEx(await bridge.resolve(FINALIZED_ARCHIVIST), () => `${FINALIZED_ARCHIVIST} not found`)
-    return assertEx(asArchivistInstance(mod), () => `${FINALIZED_ARCHIVIST} is not an archivist`)
-  }
-}

package/src/provider/index.ts

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