@xyo-network/chain-services 1.14.3 → 1.15.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.14.3",
+  "version": "1.15.0",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -54,32 +54,32 @@
     "@xyo-network/boundwitness-model": "~5.1.2",
     "@xyo-network/boundwitness-validator": "~5.1.2",
     "@xyo-network/boundwitness-wrapper": "~5.1.2",
-    "@xyo-network/chain-analyze": "~1.14.3",
-    "@xyo-network/chain-modules": "~1.14.3",
-    "@xyo-network/chain-protocol": "~1.14.3",
-    "@xyo-network/chain-utils": "~1.14.3",
+    "@xyo-network/chain-analyze": "~1.15.0",
+    "@xyo-network/chain-modules": "~1.15.0",
+    "@xyo-network/chain-protocol": "~1.15.0",
+    "@xyo-network/chain-utils": "~1.15.0",
     "@xyo-network/payload-builder": "~5.1.2",
     "@xyo-network/payload-model": "~5.1.2",
     "@xyo-network/typechain": "~4.0.8",
-    "@xyo-network/xl1-protocol": "~1.12.22",
-    "@xyo-network/xl1-protocol-sdk": "~1.14.3",
-    "@xyo-network/xl1-validation": "~1.14.3",
-    "@xyo-network/xl1-wrappers": "~1.14.3",
+    "@xyo-network/xl1-protocol": "~1.12.32",
+    "@xyo-network/xl1-protocol-sdk": "~1.15.0",
+    "@xyo-network/xl1-validation": "~1.15.0",
+    "@xyo-network/xl1-wrappers": "~1.15.0",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
     "lru-cache": "~11.2.1"
   },
   "devDependencies": {
-    "@types/node": "~24.3.1",
+    "@types/node": "~24.4.0",
     "@xylabs/delay": "~5.0.11",
     "@xylabs/ts-scripts-yarn3": "~7.1.7",
     "@xylabs/tsconfig": "~7.1.7",
     "@xylabs/vitest-extended": "~5.0.11",
     "@xyo-network/account": "~5.1.2",
     "@xyo-network/account-model": "~5.1.2",
-    "@xyo-network/chain-validation": "~1.14.3",
+    "@xyo-network/chain-validation": "~1.15.0",
     "@xyo-network/wallet": "~5.1.2",
-    "eslint": "^9.34.0",
+    "eslint": "^9.35.0",
     "tslib": "~2.8.1",
     "typescript": "~5.9.2",
     "vitest": "~3.2.4",

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -8,7 +8,7 @@ import {
 } from '@xyo-network/xl1-protocol'
 import {
   BalancesStepSummary,
-  balanceSummary,
+  balancesSummary,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import { BaseService } from '../BaseService.ts'
@@ -23,7 +23,7 @@ export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
 export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceServiceParams> implements AccountBalanceServiceV2 {
   async balances(head: Hash, address: Address[]): Promise<Partial<Record<Address, AttoXL1>>> {
     return await spanRootAsync('balances', async () => {
-      const summary = await balanceSummary({
+      const summary = await balancesSummary({
         chainArchivist: this.params.chainArchivist, summaryRepository: this.params.summaryRepository, head,
       })
       const result: Record<Address, AttoXL1> = {}

package/src/AccountBalance/accountBalanceServiceFromArchivist.ts

@@ -43,6 +43,3 @@ export const accountBalanceServiceFromArchivist = async (archivist: ReadArchivis
   const service = await BaseAccountBalanceService.create({ chainArchivist: archivist, summaryRepository })
   return service
 }
-
-/** @deprecated use accountBalanceServiceFromArchivist */
-export const accountBalanceServiceFromArchivistV2 = accountBalanceServiceFromArchivist

package/src/AccountTransfers/BaseAccountTransfersService.ts

@@ -0,0 +1,46 @@
+import { creatable } from '@xylabs/creatable'
+import { Address, Hash } from '@xylabs/hex'
+import { Promisable } from '@xylabs/promise'
+import { spanRootAsync } from '@xylabs/telemetry'
+import { ReadArchivist } from '@xyo-network/archivist-model'
+import {
+  AccountTransfersService,
+  AttoXL1, PayloadRepository,
+} from '@xyo-network/xl1-protocol'
+import {
+  TransfersStepSummary,
+  transfersSummary,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../model/index.ts'
+
+export interface BaseAccountTransferServiceParams extends BaseServiceParams {
+  account: Address
+  chainArchivist: ReadArchivist
+  summaryRepository: PayloadRepository<Hash, TransfersStepSummary>
+}
+
+@creatable()
+export class BaseAccountTransfersService extends BaseService<BaseAccountTransferServiceParams> implements AccountTransfersService {
+  async transfer(head: Hash, address: Address): Promise<AttoXL1> {
+    return (await this.transfers(head, [address]))[address] ?? AttoXL1(0n)
+  }
+
+  async transfers(head: Hash, addresses: Address[]): Promise<Partial<Record<Address, AttoXL1>>> {
+    return await spanRootAsync('transfers', async () => {
+      const {
+        chainArchivist, summaryRepository, account,
+      } = this.params
+      const summary = await transfersSummary({
+        chainArchivist, summaryRepository, head, account,
+      })
+      const result: Record<Address, AttoXL1> = {}
+      for (const addr of addresses) {
+        const summaryBalance = summary[addr] ?? 0n
+        result[addr] = AttoXL1(summaryBalance)
+      }
+      return result
+    })
+  }
+}

package/src/AccountTransfers/accountTransfersServiceFromArchivist.ts

@@ -0,0 +1,48 @@
+import { exists } from '@xylabs/exists'
+import type { Address, Hash } from '@xylabs/hex'
+import {
+  asHash,
+  isHash,
+} from '@xylabs/hex'
+import type { ReadArchivist } from '@xyo-network/archivist-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { AccountTransfersService } from '@xyo-network/xl1-protocol'
+import type { StepSummary, TransfersStepSummary } from '@xyo-network/xl1-protocol-sdk'
+import { LRUCache } from 'lru-cache'
+
+import { BaseAccountTransfersService } from './BaseAccountTransfersService.ts'
+
+export const accountTransferServiceFromArchivist = async (archivist: ReadArchivist, account: Address): Promise<AccountTransfersService> => {
+  const summaryArchivistCache = new LRUCache<Hash, WithStorageMeta<TransfersStepSummary>>({
+    max: 100_000,
+    allowStale: true,
+    noDisposeOnSet: false,
+    updateAgeOnGet: true,
+  })
+  const summaryRepository = {
+    get: (hashes: Hash[]) => {
+      const results = hashes.map((hash) => {
+        return summaryArchivistCache.get(hash)
+      }).filter(exists)
+      return results
+    },
+    insert: async (payloads: TransfersStepSummary[]) => {
+      const results = (await PayloadBuilder.addStorageMeta(payloads)).map((payload) => {
+        const hash = asHash((payload as WithStorageMeta<StepSummary>).hash)
+        if (isHash(hash)) {
+          summaryArchivistCache.set(hash, payload)
+          return payload
+        }
+      }).filter(exists)
+      return results
+    },
+    next: () => {
+      throw new Error('Not implemented')
+    },
+  }
+  const service = await BaseAccountTransfersService.create({
+    chainArchivist: archivist, account, summaryRepository,
+  })
+  return service
+}

package/src/AccountTransfers/index.ts

@@ -0,0 +1,2 @@
+export * from './accountTransfersServiceFromArchivist.ts'
+export * from './BaseAccountTransfersService.ts'

package/src/BlockProducer/BaseBlockProducerService.ts

@@ -4,6 +4,7 @@ import { exists } from '@xylabs/exists'
 import {
   Address, Hex, hexToBigInt, toHex,
 } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
 import {
   BlockRewardDiviner, FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema,
@@ -12,12 +13,10 @@ import { buildNextBlock, createDeclarationIntent } from '@xyo-network/chain-prot
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import { WithStorageMeta } from '@xyo-network/payload-model'
 import {
-  AccountBalanceServiceV2,
-  AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumber, BlockNumberSchema,
-  BlockProducerService, ChainStakeIntent,
-  defaultRewardRatio,
-  HydratedBlock, PendingTransactionsService, SignedHydratedTransaction, StakeIntentService,
-  TimePayload, TimeSchema, TimeSyncViewInterface, Transfer,
+  AccountBalanceServiceV2, AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumber, BlockNumberSchema, BlockProducerService,
+  ChainStakeIntent, defaultRewardRatio, HydratedBlock, PendingTransactionsService, SignedHydratedTransaction, StakeIntentService, TimePayload, TimeSchema,
+  TimeSyncViewInterfaceV2, Transfer,
+  XYO_STEP_REWARD_ADDRESS,
 } from '@xyo-network/xl1-protocol'
 
 import { BaseService } from '../BaseService.ts'
@@ -29,9 +28,9 @@ import { generateTransactionFeeTransfers } from './generateTransactionFeeTransfe
  */
 export const DEFAULT_BLOCK_SIZE = 10
 
-// /**
-//  * The amount of time for which a producer will restake their intent
-//  */
+/**
+ * The amount of time for which a producer will restake their intent
+ */
 export const XYO_PRODUCER_REDECLARATION_DURATION = 10_000
 
 /**
@@ -45,7 +44,7 @@ export interface BaseBlockProducerServiceParams extends XyoValidatorParams {
   pendingTransactionsService: PendingTransactionsService
   rejectedTransactionsArchivist: ArchivistInstance
   rewardAddress: Address
-  time: TimeSyncViewInterface
+  time: TimeSyncViewInterfaceV2
 }
 
 @creatable()
@@ -119,7 +118,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return assertEx(this.params.stakeIntentService, () => 'No StakeIntentService provided')
   }
 
-  protected get time(): TimeSyncViewInterface {
+  protected get time(): TimeSyncViewInterfaceV2 {
     return assertEx(this.params.time, () => 'No TimeSyncViewInterface provided')
   }
 
@@ -138,7 +137,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return this.proposeNextValidBlock(head)
   }
 
-  protected async getBlockRewardTransfer(block: number): Promise<Transfer | undefined> {
+  protected async getBlockRewardTransfers(block: number): Promise<Transfer[]> {
     if (!this._blockRewardDiviner) {
       // TODO: Adjust to allow for genesis block reward vs. normal block reward
       this._blockRewardDiviner = await FixedPercentageBlockRewardDiviner.create({
@@ -154,8 +153,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     const blockHex = assertEx(toHex(block), () => 'Failed to convert block to hex')
     const blockId = new PayloadBuilder<BlockNumber>({ schema: BlockNumberSchema }).fields({ block: blockHex }).build()
     const rewards = await this._blockRewardDiviner.divine([blockId])
-    const [reward] = rewards
-    return reward as Transfer | undefined
+    return rewards as Transfer[]
   }
 
   /**
@@ -193,15 +191,15 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       const producerRedeclarationPayload = await this.getProducerRedeclaration(head)
       if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload)
 
-      // If there are no transactions and no payloads, we don't need to create a block
-      if (blockPayloads.length === 0 && nextBlockTransactions.length === 0) return
+      // If there are no transactions, no payloads and no heartbeat required, we don't need to create a block
+      if (blockPayloads.length === 0 && nextBlockTransactions.length === 0 && !this.heartbeatRequired(head)) return
 
       // Calculate the optional block reward transfer and add if necessary
-      const rewardTransferPayload = await this.getBlockRewardTransfer(nextBlock)
-      if (rewardTransferPayload) blockPayloads.push(rewardTransferPayload)
+      const rewardTransferPayloads = await this.getBlockRewardTransfers(nextBlock)
+      blockPayloads.push(...rewardTransferPayloads)
 
       const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions)
-      const timePayload = await this.generateTimePayload(nextBlock)
+      const timePayload = await this.generateTimePayload(head)
 
       const [fundedNextBlockTransactions, fundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, validateBalances)
 
@@ -210,7 +208,8 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       // Build the block
       this.logger?.info(`Building block ${head.block + 1}`)
       const startBuild = Date.now()
-      const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account])
+      const stepRewardPoolBalance = (await this.balanceService.balances(head._hash, [XYO_STEP_REWARD_ADDRESS]))[XYO_STEP_REWARD_ADDRESS]
+      const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account], XYO_STEP_REWARD_ADDRESS, stepRewardPoolBalance)
 
       this.logger?.info(
         `Built block ${block[0].block} in ${Date.now() - startBuild}ms with ${block[1].length} payloads`,
@@ -259,14 +258,35 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return [fundedTransactions, fundedTransfers]
   }
 
-  private async generateTimePayload(nextBlock: number) {
+  private async generateTimePayload(head: WithStorageMeta<BlockBoundWitness>) {
+    const [ethereum, ethHashOrNull] = await this.time.currentTimeAndHash('ethereum')
+    const ethereumHash = assertEx(ethHashOrNull, () => 'No ethereum hash available from time sync service')
     const timePayload: TimePayload = {
       schema: TimeSchema,
-      xl1: nextBlock,
-      // TODO: Change to entire tuple for time in ETH
-      ethereum: (await this.time.currentTime('ethereum'))[1],
+      // note, this is for the previous block
+      xl1: head.block,
+      // note, this is for the previous block
+      xl1Hash: head._hash,
+      ethereum,
+      ethereumHash,
       epoch: Date.now(),
     }
     return timePayload
   }
+
+  /**
+   * Check if a heartbeat block is required based on network activity.
+   * @param head The current head block
+   * @returns True if a heartbeat is required, false otherwise
+   */
+  private heartbeatRequired(head: WithStorageMeta<BlockBoundWitness>): boolean {
+    const epoch = head.$epoch
+    if (isDefined(epoch)) {
+      const { heartbeatInterval } = this.params.config.producer
+      if (Date.now() - epoch > heartbeatInterval) {
+        return true
+      }
+    }
+    return false
+  }
 }

package/src/BlockProducer/spec/BaseBlockProducerService.spec.ts

@@ -23,7 +23,7 @@ import type {
   HydratedBlock,
   HydratedBlockStateValidationFunctionV2,
   StakeIntentService,
-  TimeSyncViewInterface,
+  TimeSyncViewInterfaceV2,
 } from '@xyo-network/xl1-protocol'
 import {
   asBlockBoundWitness,
@@ -61,7 +61,7 @@ describe('XyoBlockProducer', () => {
   let rewardAddress = '1111111111111111111111111111111111111111' as Address
   let rewardService: BlockRewardService
   let stakeIntentService: ReturnType<typeof mock<StakeIntentService>>
-  let time: TimeSyncViewInterface
+  let time: TimeSyncViewInterfaceV2
   let transactionAccount: AccountInstance
   const validPendingTransactions = Math.ceil(BaseBlockProducerService.DefaultBlockSize)
   let config: Config
@@ -95,7 +95,7 @@ describe('XyoBlockProducer', () => {
 
     stakeIntentService = mock<StakeIntentService>()
     stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([])
-    time = mock<TimeSyncViewInterface>()
+    time = mock<TimeSyncViewInterfaceV2>()
     rewardService = await MemoryBlockRewardService.create()
     const balanceService = await accountBalanceServiceFromArchivist(chainArchivist)
     const params: BaseBlockProducerServiceParams = {

package/src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts

@@ -0,0 +1,66 @@
+import { creatable } from '@xylabs/creatable'
+import { Address } from '@xylabs/hex'
+import { Promisable } from '@xylabs/promise'
+import { ReadArchivist } from '@xyo-network/archivist-model'
+import { EventingChainBlockNumberIteratorService, NetworkStakeStepRewardService } from '@xyo-network/xl1-protocol'
+import { Provider } from 'ethers'
+
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../model/index.ts'
+
+export interface BaseNetworkStakeStepRewardServiceParams extends BaseServiceParams {
+  chainArchivist: ReadArchivist
+  chainIterator: EventingChainBlockNumberIteratorService
+  ethProvider?: Provider
+}
+
+@creatable()
+export class BaseNetworkStakeStepRewardService extends BaseService<BaseNetworkStakeStepRewardServiceParams> implements NetworkStakeStepRewardService {
+  claimedRewards(address: Address): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepAddressReward(address: Address, step: number, block: number): Promisable<Record<Address, bigint>> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepPoolRewardShares(step: number, block: number): Promisable<Record<Address, bigint>> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepPoolRewards(step: number, block: number): Promisable<Record<Address, bigint>> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardAddressHistory(address: Address): Promisable<Record<Address, bigint>> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardAddressShare(address: Address, step: number, block: number): Promisable<[bigint, bigint]> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardForStep(step: number): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardPositionWeight(position: bigint, step: number): Promisable<number> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardPotentialPositionLoss(position: bigint, step: number): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardRandomizer(step: number, block: number): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardWeightForAddress(address: Address, step: number): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+
+  unclaimedRewards(address: Address): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+}

package/src/NetworkStakeStepReward/index.ts

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

package/src/Time/BaseTimeSyncService.ts

@@ -1,15 +1,23 @@
 import { assertEx } from '@xylabs/assert'
 import { creatable } from '@xylabs/creatable'
+import { asHash, Hash } from '@xylabs/hex'
+import { Promisable } from '@xylabs/promise'
 import { ReadArchivist } from '@xyo-network/archivist-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
 import {
   asTimePayload,
-  EventingChainBlockNumberIteratorService, TimeDomain, TimeSchema, TimeSyncService,
+  EventingChainBlockNumberIteratorService, TimeDomain, TimePayload, TimeSchema,
+  TimeSyncServiceV2,
 } from '@xyo-network/xl1-protocol'
 import { Provider } from 'ethers'
 
 import { BaseService } from '../BaseService.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
+export interface TimeProvider {
+  currentTime(): Promise<[string, number]>
+}
+
 export interface BaseTimeServiceParams extends BaseServiceParams {
   chainArchivist: ReadArchivist
   chainIterator: EventingChainBlockNumberIteratorService
@@ -17,7 +25,7 @@ export interface BaseTimeServiceParams extends BaseServiceParams {
 }
 
 @creatable()
-export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> implements TimeSyncService {
+export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> implements TimeSyncServiceV2 {
   get chainArchivist() {
     return this.params.chainArchivist
   }
@@ -76,4 +84,30 @@ export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> impl
       }
     }
   }
+
+  async currentTimeAndHash(domain: TimeDomain): Promise<[number, Hash | null]> {
+    switch (domain) {
+      case 'xl1': {
+        const head = await this.chainIterator.head()
+        return [head.block, await PayloadBuilder.hash(head)]
+      }
+      case 'epoch': {
+        return [Date.now(), null]
+      }
+      case 'ethereum': {
+        const provider = assertEx(this.ethProvider, () => 'Ethereum provider not configured')
+        const blockNumber = (await provider.getBlockNumber()) ?? 0
+        const block = await provider.getBlock(blockNumber)
+        const blockHash = asHash(assertEx(block?.hash, () => 'Block hash not found'), true)
+        return [blockNumber, blockHash]
+      }
+      default: {
+        throw new Error(`Unknown time domain: ${domain}`)
+      }
+    }
+  }
+
+  currentTimePayload(): Promisable<TimePayload> {
+    throw new Error('Method not implemented.')
+  }
 }

package/src/index.ts

@@ -1,13 +1,14 @@
 export * from './AccountBalance/index.ts'
+export * from './AccountTransfers/index.ts'
 export * from './BaseService.ts'
 export * from './BlockProducer/index.ts'
 export * from './BlockReward/index.ts'
-export * from './Bridge/index.ts'
 export * from './ChainBlockNumberIteration/index.ts'
 export * from './ChainService/index.ts'
 export * from './ChainValidator/index.ts'
 export * from './Election/index.ts'
 export * from './model/index.ts'
+export * from './NetworkStakeStepReward/index.ts'
 export * from './PendingTransactions/index.ts'
 export * from './StakeIntent/index.ts'
 export * from './StepStake/index.ts'

package/dist/neutral/Bridge/BaseBridgeService.d.ts

@@ -1,15 +0,0 @@
-import { Promisable } from '@xylabs/promise';
-import { ReadArchivist } from '@xyo-network/archivist-model';
-import { BridgeBack, BridgeComplete, BridgeRequest, BridgeService } from '@xyo-network/xl1-protocol';
-import { BaseService } from '../BaseService.ts';
-import { BaseServiceParams } from '../model/index.ts';
-export interface BaseBridgeServiceParams extends BaseServiceParams {
-    chainArchivist: ReadArchivist;
-}
-export declare class BaseBridgeService extends BaseService<BaseBridgeServiceParams> implements BridgeService {
-    completedBridgeBack(): Promisable<BridgeBack[]>;
-    completedBridgeRequests(): Promisable<[BridgeRequest, BridgeComplete][]>;
-    pendingBridgeBack(): Promisable<BridgeBack[]>;
-    pendingBridgeRequests(): Promisable<BridgeRequest[]>;
-}
-//# sourceMappingURL=BaseBridgeService.d.ts.map

package/dist/neutral/Bridge/BaseBridgeService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseBridgeService.d.ts","sourceRoot":"","sources":["../../../src/Bridge/BaseBridgeService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EACL,UAAU,EACV,cAAc,EACd,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAA;AAElC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAErD,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE,cAAc,EAAE,aAAa,CAAA;CAC9B;AAED,qBACa,iBAAkB,SAAQ,WAAW,CAAC,uBAAuB,CAAE,YAAW,aAAa;IAClG,mBAAmB,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;IAI/C,uBAAuB,IAAI,UAAU,CAAC,CAAC,aAAa,EAAE,cAAc,CAAC,EAAE,CAAC;IAIxE,iBAAiB,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;IAI7C,qBAAqB,IAAI,UAAU,CAAC,aAAa,EAAE,CAAC;CAGrD"}

package/dist/neutral/Bridge/index.d.ts

@@ -1,2 +0,0 @@
-export * from './BaseBridgeService.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/neutral/Bridge/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Bridge/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA"}

package/src/Bridge/BaseBridgeService.ts

@@ -1,35 +0,0 @@
-import { creatable } from '@xylabs/creatable'
-import { Promisable } from '@xylabs/promise'
-import { ReadArchivist } from '@xyo-network/archivist-model'
-import {
-  BridgeBack,
-  BridgeComplete,
-  BridgeRequest,
-  BridgeService,
-} from '@xyo-network/xl1-protocol'
-
-import { BaseService } from '../BaseService.ts'
-import { BaseServiceParams } from '../model/index.ts'
-
-export interface BaseBridgeServiceParams extends BaseServiceParams {
-  chainArchivist: ReadArchivist
-}
-
-@creatable()
-export class BaseBridgeService extends BaseService<BaseBridgeServiceParams> implements BridgeService {
-  completedBridgeBack(): Promisable<BridgeBack[]> {
-    throw new Error('Method not implemented.')
-  }
-
-  completedBridgeRequests(): Promisable<[BridgeRequest, BridgeComplete][]> {
-    throw new Error('Method not implemented.')
-  }
-
-  pendingBridgeBack(): Promisable<BridgeBack[]> {
-    throw new Error('Method not implemented.')
-  }
-
-  pendingBridgeRequests(): Promisable<BridgeRequest[]> {
-    throw new Error('Method not implemented.')
-  }
-}

package/src/Bridge/index.ts

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