@xyo-network/chain-services 1.0.1

package/src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts

@@ -0,0 +1,44 @@
+import { filterAs } from '@xylabs/array'
+import { asElevated, asOptionalChainStakeIntent, BlockBoundWitness, ChainStakeIntent, ChainStakeIntentSchema, Intent } from '@xyo-network/chain-model'
+import { exists } from '@xylabs/exists'
+import { Hash } from '@xylabs/hex'
+import { ArchivistInstance } from '@xyo-network/archivist-model'
+import { asOptionalBoundWitness, BoundWitness } from '@xyo-network/boundwitness-model'
+import { payloadSchemasContains } from '@xyo-network/boundwitness-validator'
+import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
+
+export const getBlockSignedStakeDeclarations = async (block: BlockBoundWitness, archivist: ArchivistInstance, intent: Intent): Promise<ChainStakeIntent[]> => {
+  // Get payloads in block
+  const blockData = await archivist.get(block.payload_hashes)
+  // Filter Payloads in block to BoundWitnesses
+  const bwsFromBlock = filterAs(blockData, asOptionalBoundWitness)
+  // Filter to BoundWitnesses with StakeIntent payloads
+  const bwsFromBlockWithDeclarations = bwsFromBlock.filter(bw => payloadSchemasContains(bw, ChainStakeIntentSchema))
+  // Filter to only valid signed BWs
+  const validBlockBwsWithDeclarations = await filterToValidSignedBoundWitnesses(bwsFromBlockWithDeclarations)
+  return (await Promise.all(validBlockBwsWithDeclarations.map(async (bw) => {
+    // Get staked intent hashes from signed declarations
+    const stakeIntentHashes = validBlockBwsWithDeclarations
+      .flatMap(mapBoundWitnessToStakeIntentHashes)
+      .filter(exists)
+    // Get staked intent payloads
+    const payloads = await archivist.get(stakeIntentHashes)
+    // Filter payloads to staked intents
+    const stakeIntents = filterAs(filterAs(payloads, asOptionalChainStakeIntent), asElevated)
+      // that are producers
+      .filter(p => p.intent === intent)
+      // where the issuer of the intent is also the signer of this BW
+      .filter(p => bw.addresses.includes(p.from))
+
+    return stakeIntents
+  }))).flat()
+}
+
+const filterToValidSignedBoundWitnesses = async (bws: BoundWitness[]): Promise<BoundWitness[]> => {
+  const validBwIndexes = await Promise.all(bws.map(bw => BoundWitnessWrapper.parse(bw).getValid()))
+  return bws.filter((_, index) => validBwIndexes[index])
+}
+
+const mapBoundWitnessToStakeIntentHashes = (bw: BoundWitness): (Hash | undefined)[] => {
+  return bw.payload_schemas.map((schema, index) => schema === ChainStakeIntentSchema ? bw.payload_hashes[index] : undefined)
+}

package/src/StakeIntent/lib/index.ts

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

package/src/Staker/Evm/Evm.ts

@@ -0,0 +1,117 @@
+import { BaseServiceParams, ChainService } from '@xyo-network/chain-model'
+import { Address, toAddress } from '@xylabs/hex'
+import { Base } from '@xylabs/object'
+import { Promisable } from '@xylabs/promise'
+import { StakedXyoChain, StakedXyoChain__factory as StakedXyoChainFactory } from '@xyo-network/typechain'
+import { getAddress } from 'ethers/address'
+import { ContractRunner } from 'ethers/providers'
+
+export interface EvmChainServiceParams extends BaseServiceParams {
+  contract: StakedXyoChain
+  id: Address
+  runner: ContractRunner
+}
+
+/**
+ * A class that represents a chain stake as backed by an EVM smart contract
+ */
+export class EvmChainService extends Base<EvmChainServiceParams> implements ChainService {
+  private _contract: StakedXyoChain
+
+  protected constructor(params: EvmChainServiceParams) {
+    super(params)
+    this._contract = params.contract
+  }
+
+  get id(): Address {
+    return this.params.id
+  }
+
+  get runner(): ContractRunner {
+    return this.params.runner
+  }
+
+  static create({
+    id, runner, logger, traceProvider, meterProvider,
+  }: Omit<EvmChainServiceParams, 'contract'>): Promisable<EvmChainService> {
+    const contractAddress = getAddress(id)
+    const contract: StakedXyoChain = StakedXyoChainFactory.connect(contractAddress, runner)
+    return new this({
+      id, contract, runner, logger, traceProvider, meterProvider,
+    })
+  }
+
+  async active(): Promise<bigint> {
+    return await this._contract.active()
+  }
+
+  async activeByAddressStaked(address: string): Promise<bigint> {
+    return await this._contract.activeByAddressStaked(getAddress(address))
+  }
+
+  async activeByStaker(address: string): Promise<bigint> {
+    return await this._contract.activeByStaker(getAddress(address))
+  }
+
+  async addStake(staked: string, amount: bigint): Promise<boolean> {
+    const result = await this._contract.addStake(getAddress(staked), amount)
+    await result.wait()
+    return true
+  }
+
+  async chainId(): Promise<Address> {
+    return toAddress(await this._contract.chainId())
+  }
+
+  async forkedAtBlockNumber(): Promise<bigint> {
+    return await this._contract.forkedAtBlockNumber()
+  }
+
+  async forkedAtHash(): Promise<bigint> {
+    return await this._contract.forkedAtHash()
+  }
+
+  async forkedChainId(): Promise<Address> {
+    return toAddress(await this._contract.forkedChainId())
+  }
+
+  async minWithdrawalBlocks(): Promise<bigint> {
+    return await this._contract.minWithdrawalBlocks()
+  }
+
+  async pending(): Promise<bigint> {
+    return await this._contract.pending()
+  }
+
+  async pendingByStaker(staker: string): Promise<bigint> {
+    return await this._contract.pendingByStaker(getAddress(staker))
+  }
+
+  async removeStake(slot: bigint): Promise<boolean> {
+    const result = await this._contract.removeStake(slot)
+    await result.wait()
+    return true
+  }
+
+  async rewardsContract(): Promise<string> {
+    return await this._contract.rewardsContract()
+  }
+
+  async stakingTokenAddress(): Promise<string> {
+    return await this._contract.stakingTokenAddress()
+  }
+
+  async withdrawStake(slot: bigint): Promise<boolean> {
+    const result = await this._contract.withdrawStake(slot)
+    await result.wait()
+    return true
+  }
+
+  async withdrawn(): Promise<bigint> {
+    return await this._contract.withdrawn()
+  }
+
+  async withdrawnByStaker(staker: string): Promise<bigint> {
+    return await this._contract.withdrawnByStaker(getAddress(staker))
+  }
+}

package/src/Staker/Evm/index.ts

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

package/src/Staker/index.ts

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

package/src/XyoChainBlockNumberIterator.ts

@@ -0,0 +1,98 @@
+import { assertEx } from '@xylabs/assert'
+import {
+  asBlockBoundWitness, asOptionalBlockBoundWitness, BlockBoundWitness, ChainIdentification,
+  ChainIteratorEventData,
+  EventingChainBlockNumberIterator,
+  isBlockBoundWitness,
+  XyoChainIteratorParams,
+} from '@xyo-network/chain-model'
+import { BaseParams } from '@xylabs/object'
+import { ArchivistInstance } from '@xyo-network/archivist-model'
+import { BaseEmitter } from '@xyo-network/module-event-emitter'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { LRUCache } from 'lru-cache'
+
+export class XyoChainBlockNumberIterator extends BaseEmitter<BaseParams, ChainIteratorEventData> implements EventingChainBlockNumberIterator {
+  protected _blocksByBlockNumber = new LRUCache<number, BlockBoundWitness>({ max: 10_000 })
+  protected _chainArchivist: ArchivistInstance
+  protected _chainInformation: ChainIdentification
+  protected _head: BlockBoundWitness
+
+  protected constructor(params: XyoChainIteratorParams) {
+    super({})
+    const { chainArchivist: archivist, head } = params
+    this._chainArchivist = archivist
+    this._head = head
+    this._chainInformation = { id: head.chain }
+  }
+
+  get archivist(): ArchivistInstance { return this._chainArchivist }
+
+  get chainIdentification(): ChainIdentification { return this._chainInformation }
+
+  static async create(params: XyoChainIteratorParams): Promise<XyoChainBlockNumberIterator> {
+    await Promise.resolve()
+    return new XyoChainBlockNumberIterator(params)
+  }
+
+  async get(block: number): Promise<BlockBoundWitness> {
+    // Bail early if the block requested is newer than the current head
+    assertEx(this._head.block >= block, () => `Block requested is newer than the current head [${block}]`)
+    const cached = this._blocksByBlockNumber.get(block)
+    if (cached) return cached
+    // Start at the current head and traverse backwards until the requested block is found
+    const startingBlock = this._head
+    const currentBlockHash = await PayloadBuilder.hash(startingBlock)
+    let [currentBlock] = await this._chainArchivist.get([currentBlockHash])
+    while (currentBlock) {
+      assertEx(asBlockBoundWitness(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock._hash}]`)
+      if (isBlockBoundWitness(currentBlock)) {
+        this._blocksByBlockNumber.set(currentBlock.block, currentBlock)
+        if (currentBlock.block === block) {
+          return currentBlock
+        }
+        const { previous } = currentBlock
+        if (!previous) break
+        [currentBlock] = await this._chainArchivist.get([previous])
+      }
+    }
+    throw new Error(`Block not found: ${block}`)
+  }
+
+  async head(): Promise<BlockBoundWitness> {
+    return await Promise.resolve(this._head)
+  }
+
+  async next(block: number): Promise<BlockBoundWitness | undefined> {
+    const currentBlock = block
+    const nextBlockNumber = currentBlock + 1
+    return await this.get(nextBlockNumber)
+  }
+
+  // TODO: Decide on inclusive/exclusive (probably need inclusive to account for chain head)
+  // and then communicate via method name and documentation
+  async previous(block: number | undefined = undefined, count: number = 1): Promise<BlockBoundWitness[]> {
+    const results: BlockBoundWitness[] = []
+    let currentBlock: BlockBoundWitness | undefined = block ? (await this.get(block)) : this._head
+    while (currentBlock && results.length < count) {
+      if (isBlockBoundWitness(currentBlock)) {
+        results.push(currentBlock)
+        const { previous } = currentBlock
+        if (!previous) break
+        const nextBlock = await this._chainArchivist.get([previous])
+        currentBlock = asOptionalBlockBoundWitness(nextBlock[0])
+      } else {
+        const hash = PayloadBuilder.hash(currentBlock)
+        assertEx(asBlockBoundWitness(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`)
+      }
+    }
+    return results
+  }
+
+  async updateHead(head: BlockBoundWitness): Promise<void> {
+    // Async to allow for re-indexing, etc.
+    await Promise.resolve()
+    this._head = head
+    void this.emit('headUpdated', { blocks: [head] })
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './AccountBalance/index.ts'
+export * from './BaseService.ts'
+export * from './BlockProducer/index.ts'
+export * from './BlockReward/index.ts'
+export * from './ChainValidator/index.ts'
+export * from './CreatableService.ts'
+export * from './Election/index.ts'
+export * from './PendingTransactions/index.ts'
+export * from './StakeIntent/index.ts'
+export * from './Staker/index.ts'
+export * from './XyoChainBlockNumberIterator.ts'

package/xy.config.ts

@@ -0,0 +1,10 @@
+import { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
+const config: XyTsupConfig = {
+  compile: {
+    browser: { },
+    node: { },
+    neutral: { src: true },
+  },
+}
+
+export default config