@xyo-network/chain-services 1.16.16 → 1.16.17

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.16.16",
+  "version": "1.16.17",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -33,7 +33,10 @@
   "types": "./dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src"
+    "src",
+    "!**/*.bench.*",
+    "!**/*.spec.*",
+    "!**/*.test.*"
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.0",
@@ -45,17 +48,17 @@
     "@xyo-network/boundwitness-model": "~5.1.23",
     "@xyo-network/boundwitness-validator": "~5.1.23",
     "@xyo-network/boundwitness-wrapper": "~5.1.23",
-    "@xyo-network/chain-analyze": "~1.16.16",
-    "@xyo-network/chain-modules": "~1.16.16",
-    "@xyo-network/chain-protocol": "~1.16.16",
-    "@xyo-network/chain-utils": "~1.16.16",
+    "@xyo-network/chain-analyze": "~1.16.17",
+    "@xyo-network/chain-modules": "~1.16.17",
+    "@xyo-network/chain-protocol": "~1.16.17",
+    "@xyo-network/chain-utils": "~1.16.17",
     "@xyo-network/payload-builder": "~5.1.23",
     "@xyo-network/payload-model": "~5.1.23",
     "@xyo-network/typechain": "~4.0.10",
     "@xyo-network/xl1-protocol": "~1.13.11",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.16",
-    "@xyo-network/xl1-validation": "~1.16.16",
-    "@xyo-network/xl1-wrappers": "~1.16.16",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.17",
+    "@xyo-network/xl1-validation": "~1.16.17",
+    "@xyo-network/xl1-wrappers": "~1.16.17",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
     "lru-cache": "~11.2.2"
@@ -68,7 +71,7 @@
     "@xylabs/vitest-extended": "~5.0.34",
     "@xyo-network/account": "~5.1.23",
     "@xyo-network/account-model": "~5.1.23",
-    "@xyo-network/chain-validation": "~1.16.16",
+    "@xyo-network/chain-validation": "~1.16.17",
     "@xyo-network/wallet": "~5.1.23",
     "eslint": "^9.39.1",
     "tslib": "~2.8.1",

package/dist/neutral/BlockProducer/spec/BaseBlockProducerService.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=BaseBlockProducerService.spec.d.ts.map

package/dist/neutral/BlockProducer/spec/BaseBlockProducerService.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseBlockProducerService.spec.d.ts","sourceRoot":"","sources":["../../../../src/BlockProducer/spec/BaseBlockProducerService.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/BlockProducer/spec/generateTransactionTransfer.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=generateTransactionTransfer.spec.d.ts.map

package/dist/neutral/BlockProducer/spec/generateTransactionTransfer.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateTransactionTransfer.spec.d.ts","sourceRoot":"","sources":["../../../../src/BlockProducer/spec/generateTransactionTransfer.spec.ts"],"names":[],"mappings":""}

package/dist/neutral/BlockReward/spec/MemoryBlockRewardService.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=MemoryBlockRewardService.spec.d.ts.map

package/dist/neutral/BlockReward/spec/MemoryBlockRewardService.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryBlockRewardService.spec.d.ts","sourceRoot":"","sources":["../../../../src/BlockReward/spec/MemoryBlockRewardService.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/PendingTransactions/spec/BasePendingTransactions.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=BasePendingTransactions.spec.d.ts.map

package/dist/neutral/PendingTransactions/spec/BasePendingTransactions.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BasePendingTransactions.spec.d.ts","sourceRoot":"","sources":["../../../../src/PendingTransactions/spec/BasePendingTransactions.spec.ts"],"names":[],"mappings":""}

package/dist/neutral/PendingTransactions/spec/bundledPayloadToHydratedTransaction.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=bundledPayloadToHydratedTransaction.spec.d.ts.map

package/dist/neutral/PendingTransactions/spec/bundledPayloadToHydratedTransaction.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundledPayloadToHydratedTransaction.spec.d.ts","sourceRoot":"","sources":["../../../../src/PendingTransactions/spec/bundledPayloadToHydratedTransaction.spec.ts"],"names":[],"mappings":""}

package/dist/neutral/PendingTransactions/spec/hydratedTransactionToPayloadBundle.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=hydratedTransactionToPayloadBundle.spec.d.ts.map

package/dist/neutral/PendingTransactions/spec/hydratedTransactionToPayloadBundle.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hydratedTransactionToPayloadBundle.spec.d.ts","sourceRoot":"","sources":["../../../../src/PendingTransactions/spec/hydratedTransactionToPayloadBundle.spec.ts"],"names":[],"mappings":""}

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

@@ -1,391 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import type {
-  Address, CreatableName, Hash, Promisable,
-} from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx,
-  delay,
-  filterAs,
-  hexToBigInt, ZERO_HASH,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { buildRandomChain, buildRandomTransaction } from '@xyo-network/chain-protocol'
-import { validateHydratedBlockState } from '@xyo-network/chain-validation'
-import {
-  type PayloadBundle, PayloadBundleSchema, type WithStorageMeta,
-} from '@xyo-network/payload-model'
-import { HDWallet } from '@xyo-network/wallet'
-import type {
-  BlockBoundWitness, ChainId,
-  HydratedBlock,
-  TimeDomain, TimePayload,
-} from '@xyo-network/xl1-protocol'
-import {
-  asBlockBoundWitness,
-  asChainStakeIntent,
-  asTransactionBoundWitness,
-  asTransfer,
-  TimeSchema,
-  XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-protocol'
-import type {
-  BlockRewardService, Config, ElectionService, HydratedBlockStateValidationFunction, StakeIntentService,
-  TimeSyncViewer,
-} from '@xyo-network/xl1-protocol-sdk'
-import {
-  flattenHydratedBlock, flattenHydratedTransaction, getDefaultConfig,
-  HydratedBlockStateValidationError,
-} from '@xyo-network/xl1-protocol-sdk'
-import {
-  beforeAll, beforeEach, describe, expect, it,
-} from 'vitest'
-import { mock } from 'vitest-mock-extended'
-
-import { accountBalancesServiceFromArchivist } from '../../AccountBalance/index.ts'
-import { MemoryBlockRewardService } from '../../BlockReward/index.ts'
-import type { BasePendingTransactionsServiceParams } from '../../PendingTransactions/index.ts'
-import { BasePendingTransactionsService } from '../../PendingTransactions/index.ts'
-import type { BaseBlockProducerServiceParams } from '../BaseBlockProducerService.ts'
-import { BaseBlockProducerService } from '../BaseBlockProducerService.ts'
-
-describe('XyoBlockProducer', () => {
-  const leaderCount = 3
-  let account: AccountInstance
-  let blockProducer: BaseBlockProducerService
-  let chainArchivist: ArchivistInstance
-  let electionService: ReturnType<typeof mock<ElectionService>>
-  let pendingBundledTransactionsArchivist: ArchivistInstance
-  let pendingTransactionsService: BasePendingTransactionsService
-  let rejectedTransactionsArchivist: ArchivistInstance
-  let rewardAddress = '1111111111111111111111111111111111111111' as Address
-  let rewardService: BlockRewardService
-  let stakeIntentService: ReturnType<typeof mock<StakeIntentService>>
-  let time: TimeSyncViewer
-  let transactionAccount: AccountInstance
-  const validPendingTransactions = Math.ceil(BaseBlockProducerService.DefaultBlockSize)
-  let config: Config
-
-  let currentBlock: WithStorageMeta<BlockBoundWitness>
-
-  const chainId = assertEx(asAddress('Be17531fec6fEc55f3EAc3f1c187c87e4C47F81E'))
-
-  beforeAll(async () => {
-    account = await Account.random()
-    transactionAccount = await HDWallet.fromPhrase('room maximum palace fragile man pyramid school indoor base business want bronze assume marble report')
-  })
-
-  beforeEach(async () => {
-    config = getDefaultConfig()
-    config.producer.disableIntentRedeclaration = false
-    chainArchivist = await MemoryArchivist.create({ account: 'random' })
-    rejectedTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
-    electionService = mock<ElectionService>()
-    pendingBundledTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
-    const BasePendingTransactionsServiceParams: BasePendingTransactionsServiceParams = {
-      name: 'TestBasePendingTransactionsServiceParams' as CreatableName,
-      chainArchivist: chainArchivist,
-      chainId,
-      config,
-      pendingBundledTransactionsArchivist,
-      rejectedTransactionsArchivist,
-    }
-    pendingTransactionsService = await BasePendingTransactionsService.create(BasePendingTransactionsServiceParams)
-    await addPendingTransactions(validPendingTransactions)
-
-    stakeIntentService = mock<StakeIntentService>()
-    stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([])
-    time = {
-      currentTimeAndHash(domain: TimeDomain): Promisable<[number, Hash | null]> {
-        switch (domain) {
-          case 'epoch': {
-            return [Date.now(), null]
-          }
-          case 'xl1': {
-            return [1, '00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff' as Hash]
-          }
-          case 'ethereum': {
-            return [1, '00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff' as Hash]
-          }
-        // No default
-        }
-      },
-      currentTime(domain: TimeDomain): Promisable<[string, number]> {
-        switch (domain) {
-          case 'epoch': {
-            return ['epoch', Date.now()]
-          }
-          case 'xl1': {
-            return ['xl1', 1]
-          }
-          case 'ethereum': {
-            return ['ethereum', 1]
-          }
-        // No default
-        }
-      },
-      currentTimePayload(): Promisable<TimePayload> {
-        return {
-          schema: TimeSchema, epoch: Date.now(), xl1: 1,
-        }
-      },
-      /** Convert time between different domains */
-      convertTime(fromDomain: TimeDomain, toDomain: TimeDomain, from: number): Promisable<number> {
-        if (fromDomain === toDomain) {
-          return from
-        }
-        if (fromDomain === 'epoch' && toDomain === 'xl1') {
-          return 1
-        }
-        if (fromDomain === 'xl1' && toDomain === 'epoch') {
-          return Date.now()
-        }
-        return from
-      },
-    }
-    rewardService = await MemoryBlockRewardService.create()
-    const balanceService = await accountBalancesServiceFromArchivist(chainId, chainArchivist)
-    const params: BaseBlockProducerServiceParams = {
-      name: 'TestXyoBlockProducerParams' as CreatableName,
-      account,
-      balanceService,
-      chainArchivist,
-      chainId,
-      config,
-      electionService,
-      pendingTransactionsService,
-      pendingBundledTransactionsArchivist,
-      rejectedTransactionsArchivist,
-      rewardAddress,
-      rewardService,
-      stakeIntentService,
-      time,
-      validateHydratedBlockState,
-    }
-    blockProducer = await BaseBlockProducerService.create(params)
-  })
-
-  const addPendingTransactions = async (count: number = validPendingTransactions) => {
-    for (let i = 0; i < count; i++) {
-      const transaction = await buildRandomTransaction(chainId, [], transactionAccount)
-      const bundledPayload: PayloadBundle = {
-        schema: PayloadBundleSchema, payloads: flattenHydratedTransaction(transaction), root: transaction[0]._hash,
-      }
-      await pendingBundledTransactionsArchivist.insert([bundledPayload])
-    }
-  }
-
-  describe('next', () => {
-    describe('block production', () => {
-      describe('when not current block leader', () => {
-        beforeEach(async () => {
-          const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-          currentBlock = hydratedBlock[0]
-          await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-          const leaders = await Promise.all(Array.from({ length: leaderCount }, async () => (await Account.random()).address))
-          electionService.getCreatorCommitteeForNextBlock.mockResolvedValue(leaders)
-          stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([])
-        })
-        it('should return undefined', async () => {
-        // Arrange
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeUndefined()
-        })
-      })
-      describe('when current block leader', () => {
-        beforeEach(async () => {
-          const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-          currentBlock = hydratedBlock[0]
-          await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-          await delay(1000)
-          electionService.getCreatorCommitteeForNextBlock.mockResolvedValue([account.address])
-        })
-        it('should return a valid block', async () => {
-          // Arrange
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, transactionsAndData] = result ?? []
-          expect(block).toBeDefined()
-          expect(asBlockBoundWitness(block)).toBeDefined()
-          expect(transactionsAndData).toBeDefined()
-          expect(transactionsAndData).toBeArray()
-          const transactions = filterAs(assertEx(transactionsAndData), asTransactionBoundWitness)
-          expect(transactions).toBeArrayOfSize(validPendingTransactions)
-        })
-        it('should remove invalid transactions', async () => {
-          // Arrange
-          let rejectBlock = true
-          const validateHydratedBlockState: HydratedBlockStateValidationFunction = async (
-            hydratedBlock: HydratedBlock,
-            chainId: ChainId,
-          ) => {
-            return rejectBlock ? [await Promise.resolve(new HydratedBlockStateValidationError(ZERO_HASH, chainId, hydratedBlock, 'Invalid block'))] : []
-          }
-          const balanceService = await accountBalancesServiceFromArchivist(chainId, chainArchivist)
-          const params: BaseBlockProducerServiceParams = {
-            name: 'TestXyoBlockProducerParams' as CreatableName,
-            account,
-            balanceService,
-            chainArchivist,
-            chainId,
-            config,
-            electionService,
-            pendingBundledTransactionsArchivist,
-            pendingTransactionsService,
-            rejectedTransactionsArchivist,
-            rewardAddress,
-            rewardService,
-            stakeIntentService,
-            time,
-            validateHydratedBlockState,
-          }
-          blockProducer = await BaseBlockProducerService.create(params)
-
-          // Act
-          // Force producer to reject first block
-          rejectBlock = true
-          const invalidTransactionCount = Math.floor(validPendingTransactions / 2)
-          await addPendingTransactions(invalidTransactionCount)
-
-          // Ensure bad block is not produced
-          const firstResult = await blockProducer.next(currentBlock)
-          expect(firstResult).toBeUndefined()
-          // Do not reject second block
-          rejectBlock = false
-          // Add more pending transactions
-          const newTransactionCount = Math.floor(validPendingTransactions / 2)
-          await addPendingTransactions(newTransactionCount)
-          // Ensure producer recovers from bad block
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, transactionsAndData] = result ?? []
-          expect(block).toBeDefined()
-          if (block) {
-            expect(asBlockBoundWitness(block)).toBeDefined()
-            expect(transactionsAndData).toBeDefined()
-            expect(transactionsAndData).toBeArray()
-            const transactions = filterAs(assertEx(transactionsAndData), asTransactionBoundWitness)
-            expect(transactions).toBeArrayOfSize(newTransactionCount)
-            const transfers = filterAs(assertEx(transactionsAndData), asTransfer)
-            const blockRewardTransfer = transfers.find(transfer => transfer.from === XYO_ZERO_ADDRESS)
-            expect(blockRewardTransfer).toBeDefined()
-            let totalTransfer = 0n
-            for (const value of Object.values(blockRewardTransfer?.transfers ?? {})) {
-              const bigIntValue = hexToBigInt(value)
-              totalTransfer += bigIntValue
-            }
-            expect(totalTransfer).toEqual(3_000_000_000_000_000_000_000n)
-          }
-        })
-      })
-    })
-    describe('producer re-declare intent', () => {
-      describe('when within re-declare intent window', () => {
-        beforeEach(async () => {
-          const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-          currentBlock = hydratedBlock[0]
-          await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-          electionService.getCreatorCommitteeForNextBlock.mockResolvedValue([account.address])
-          stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([[0, 10]])
-        })
-        it('should re-declare intent if configured for re-declaration', async () => {
-          // Arrange
-          config.producer.disableIntentRedeclaration = false
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, payloads] = result ?? []
-          expect(block).toBeDefined()
-          expect(asBlockBoundWitness(block)).toBeDefined()
-          expect(payloads).toBeArray()
-          const allData = flattenHydratedBlock(assertEx(result))
-          const declaration = filterAs(allData, asChainStakeIntent).at(0)
-          expect(declaration).toBeDefined()
-          expect(declaration?.from).toEqual(blockProducer.address)
-        })
-        it('should not re-declare intent if not configured for re-declaration', async () => {
-        // Arrange
-          config.producer.disableIntentRedeclaration = true
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, payloads] = result ?? []
-          expect(block).toBeDefined()
-          expect(asBlockBoundWitness(block)).toBeDefined()
-          expect(payloads).toBeArray()
-          const allData = flattenHydratedBlock(assertEx(result))
-          const declaration = filterAs(allData, asChainStakeIntent).at(0)
-          expect(declaration).toBeUndefined()
-        })
-      })
-      describe('when not within re-declare intent window', () => {
-        beforeEach(async () => {
-          const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-          currentBlock = hydratedBlock[0]
-          await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-          electionService.getCreatorCommitteeForNextBlock.mockResolvedValue([account.address])
-          stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([[0, 1_000_000_000]])
-        })
-        it('should not re-declare intent if configured for re-declaration', async () => {
-          // Arrange
-          config.producer.disableIntentRedeclaration = false
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, payloads] = result ?? []
-          expect(block).toBeDefined()
-          expect(asBlockBoundWitness(block)).toBeDefined()
-          expect(payloads).toBeArray()
-          const allData = flattenHydratedBlock(assertEx(result))
-          const declaration = filterAs(allData, asChainStakeIntent).at(0)
-          expect(declaration).toBeUndefined()
-        })
-        it('should not re-declare intent if not configured for re-declaration', async () => {
-          // Arrange
-          config.producer.disableIntentRedeclaration = true
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, payloads] = result ?? []
-          expect(block).toBeDefined()
-          expect(asBlockBoundWitness(block)).toBeDefined()
-          expect(payloads).toBeArray()
-          const allData = flattenHydratedBlock(assertEx(result))
-          const declaration = filterAs(allData, asChainStakeIntent).at(0)
-          expect(declaration).toBeUndefined()
-        })
-      })
-    })
-  })
-})

package/src/BlockProducer/spec/generateTransactionTransfer.spec.ts

@@ -1,75 +0,0 @@
-import type {
-  Address, Hash, Hex,
-} from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx,
-  hexToBigInt, isDefined,
-  toHex,
-} from '@xylabs/sdk-js'
-import type { Sequence, WithStorageMeta } from '@xyo-network/payload-model'
-import { XYO_ZERO_ADDRESS } from '@xyo-network/xl1-protocol'
-import {
-  defaultTransactionFees, type SignedHydratedTransactionWithStorageMeta, type Transfer,
-} from '@xyo-network/xl1-protocol'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { generateTransactionFeeTransfers } from '../generateTransactionFeeTransfers.ts'
-
-describe('generateTransactionTransfers', () => {
-  const testCases: SignedHydratedTransactionWithStorageMeta[][] = [
-    [
-      [
-        {
-          schema: 'network.xyo.boundwitness',
-          addresses: ['39d22bed37f77bee0c056f648bde6efa489981c3' as Address],
-          payload_hashes: ['65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8' as Hash],
-          payload_schemas: ['network.xyo.transfer'],
-          previous_hashes: [null],
-          $signatures: [
-            '0605878a92045bb752cc12066b585589b513cee652bf4bc36c19289495ccd3d3751a1202b5bfb334325c4c6a59a4a7dad7468739a8b4ffe07b6091317b16dc09' as Hex,
-          ],
-          nbf: 2835,
-          exp: 3835,
-          fees: {
-            base: toHex(defaultTransactionFees.base),
-            gasLimit: toHex(defaultTransactionFees.gasLimit),
-            gasPrice: toHex(defaultTransactionFees.gasPrice),
-            priority: '00' as Hex,
-          },
-          chain: 'a82920051db4fcbb804463440dd45e03f72442fd' as Hex,
-          script: ['elevate|65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8'],
-          from: '39d22bed37f77bee0c056f648bde6efa489981c3' as Address,
-          _dataHash: '47be77303edd6073f82e9fff119107f1e173a08e7285e8e5f6e0c979d43e5b7d' as Hash,
-          _hash: '1419062ddb266ff58515c4ffbc435ec482b6129d9e0c3c707fb7610c67215281' as Hash,
-          _sequence: '00000196f46014770000000167215281' as Sequence,
-        },
-        [
-          {
-            schema: 'network.xyo.transfer',
-            epoch: 1_747_856_659_420,
-            from: '39d22bed37f77bee0c056f648bde6efa489981c3' as Address,
-            transfers: { db5df9c99e661500c95f2c933023ba693e5c1ae9: '056bc75e2d63100000' as Hex },
-            _dataHash: '65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8' as Hash,
-            _hash: '65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8' as Hash,
-            _sequence: '00000196f4601477000000002aef69c8' as Sequence,
-          } as WithStorageMeta<Transfer>,
-        ],
-      ],
-    ],
-  ]
-  it.each(testCases)('should generate correct Transfer payloads from hydrated transactions', async (...transactions) => {
-    const producerAddress = assertEx(asAddress('3e86dac7546202156c4620d3cf36fb0ac30404a3'))
-
-    // Patch the transactionRequiredGas function to return our test gas amount
-
-    const result = await generateTransactionFeeTransfers(producerAddress, transactions)
-
-    const burnValueHex = result.at(0)?.transfers[XYO_ZERO_ADDRESS]
-    expect(burnValueHex).toBeDefined()
-    const burnValue = isDefined(burnValueHex) ? hexToBigInt(burnValueHex) : 0n
-    expect(burnValue).toBeGreaterThan(0n)
-    expect(burnValue).toEqual(1_000_000_000_000n)
-  })
-})

package/src/BlockReward/spec/MemoryBlockRewardService.spec.ts

@@ -1,64 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { toFixedPoint } from '@xylabs/sdk-js'
-import {
-  beforeAll, describe, expect, it,
-} from 'vitest'
-
-import { MemoryBlockRewardService } from '../index.ts'
-
-describe('MemoryBlockRewardService', () => {
-  let sut: MemoryBlockRewardService
-  // const genesisReward = toFixedPoint(18_000_000_000n)
-  // const initialReward = toFixedPoint(500n)
-  // const minRewardPerBlock = toFixedPoint(10n)
-  const genesisReward = 18_000_000_000_000_000_000_000_000_000n
-  const initialReward = 500_000_000_000_000_000_000n
-  const minRewardPerBlock = 10_000_000_000_000_000_000n
-  const stepFactorDenominator = 100n
-  const stepFactorNumerator = 95n
-  const stepSize = 1_000_000n
-  beforeAll(async () => {
-    sut = await MemoryBlockRewardService.create({
-      stepFactorNumerator,
-      stepFactorDenominator,
-      stepSize,
-      initialStepReward: initialReward,
-      minRewardPerBlock,
-      creatorReward: genesisReward,
-    })
-  })
-
-  describe('rewards', () => {
-    it('for block 0', async () => {
-      const reward = await sut.getRewardForBlock(0n)
-      expect(reward).toEqual(18_000_000_000_000_000_000_000_000_000n)
-      expect(reward).toEqual(toFixedPoint(18_000_000_000n))
-    })
-    it('for block 1', async () => {
-      const reward = await sut.getRewardForBlock(1n)
-      expect(reward).toEqual(500_000_000_000_000_000_000n)
-      expect(reward).toEqual(toFixedPoint(500n))
-    })
-    it('for block 2', async () => {
-      const reward = await sut.getRewardForBlock(2n)
-      expect(reward).toEqual(500_000_000_000_000_000_000n)
-      expect(reward).toEqual(toFixedPoint(500n))
-    })
-    it('for block 3', async () => {
-      const reward = await sut.getRewardForBlock(3n)
-      expect(reward).toEqual(500_000_000_000_000_000_000n)
-      expect(reward).toEqual(toFixedPoint(500n))
-    })
-    it('for block 4', async () => {
-      const reward = await sut.getRewardForBlock(4n)
-      expect(reward).toEqual(500_000_000_000_000_000_000n)
-      expect(reward).toEqual(toFixedPoint(500n))
-    })
-    it('for block 1000000', async () => {
-      const reward = await sut.getRewardForBlock(1_000_000n)
-      expect(reward).toEqual(475_000_000_000_000_000_000n)
-      expect(reward).toEqual(toFixedPoint(475n))
-    })
-  })
-})

package/src/PendingTransactions/spec/BasePendingTransactions.spec.ts

@@ -1,276 +0,0 @@
-import type { CreatableName } from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx, delay,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import {
-  buildRandomChain, buildRandomTransaction,
-  findMostRecentBlock, TestChainId,
-} from '@xyo-network/chain-protocol'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { WithStorageMeta } from '@xyo-network/payload-model'
-import type {
-  BlockBoundWitness, HashPayload,
-  HydratedBlock,
-  SignedHydratedTransactionWithStorageMeta,
-} from '@xyo-network/xl1-protocol'
-import { HashSchema } from '@xyo-network/xl1-protocol'
-import {
-  buildTransaction, flattenHydratedBlock, flattenHydratedTransactions,
-  getDefaultConfig,
-} from '@xyo-network/xl1-protocol-sdk'
-import {
-  beforeAll,
-  beforeEach, describe, expect, it,
-} from 'vitest'
-
-import type { BasePendingTransactionsServiceParams } from '../BasePendingTransactions.ts'
-import { BasePendingTransactionsService } from '../BasePendingTransactions.ts'
-import { hydratedTransactionToPayloadBundle } from '../hydratedTransactionToPayloadBundle.ts'
-
-describe('BasePendingTransactionsService', () => {
-  let sut: BasePendingTransactionsService
-  let chainArchivist: ArchivistInstance
-  let pendingBundledTransactionsArchivist: ArchivistInstance
-  let rejectedTransactionsArchivist: ArchivistInstance
-  let producer: AccountInstance
-  let chain: HydratedBlock[]
-  let head: WithStorageMeta<BlockBoundWitness>
-  const chainId = TestChainId
-  const config = getDefaultConfig()
-
-  beforeAll(async () => {
-    producer = await Account.random()
-  })
-
-  beforeEach(async () => {
-    chain = await buildRandomChain(producer, 10)
-    chainArchivist = await MemoryArchivist.create({ account: 'random' })
-    await chainArchivist.insert(chain.flatMap(block => flattenHydratedBlock(block)))
-    pendingBundledTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
-    rejectedTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
-    head = assertEx(await findMostRecentBlock(chainArchivist))
-    const params: BasePendingTransactionsServiceParams = {
-      name: 'TestBasePendingTransactionsServiceParams' as CreatableName,
-      chainArchivist,
-      chainId,
-      config,
-      pendingBundledTransactionsArchivist,
-      rejectedTransactionsArchivist,
-    }
-    sut = await BasePendingTransactionsService.create(params)
-  })
-
-  describe('with pending transactions', () => {
-    let newTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-    beforeEach(async () => {
-      for (let index = 0; index < 5; index++) {
-        const tx = await buildRandomTransaction(TestChainId)
-        newTransactions.push(tx)
-        await delay(2)
-      }
-      const payloads = newTransactions.map(hydratedTransactionToPayloadBundle)
-      await pendingBundledTransactionsArchivist.insert(payloads)
-    })
-    it('should return the requested amount of hydrated transactions', async () => {
-      const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-      expect(result.length).toEqual(newTransactions.length)
-    })
-  })
-
-  describe('with no pending transactions', () => {
-    it('should return an empty array', async () => {
-      const result = await sut.getPendingTransactions(head._dataHash, 10)
-      expect(result).toEqual([])
-    })
-  })
-
-  describe('with pending and finalized transactions', () => {
-    let finalizedTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-    let newTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-    beforeEach(async () => {
-      for (let index = 0; index < 5; index++) {
-        const tx = await buildRandomTransaction(TestChainId)
-        finalizedTransactions.push(tx)
-        await delay(2)
-      }
-      await pendingBundledTransactionsArchivist.insert(finalizedTransactions.map(hydratedTransactionToPayloadBundle))
-      await chainArchivist.insert(flattenHydratedTransactions(finalizedTransactions))
-      for (let index = 0; index < 5; index++) {
-        const tx = await buildRandomTransaction(TestChainId)
-        newTransactions.push(tx)
-        await delay(2)
-      }
-      const pending = newTransactions.map(hydratedTransactionToPayloadBundle)
-      await pendingBundledTransactionsArchivist.insert(pending)
-    })
-    it('should remove finalized transactions from pending', async () => {
-      const result = await sut.getPendingTransactions(head._hash, newTransactions.length + finalizedTransactions.length)
-      expect(result.length).toEqual(newTransactions.length)
-    })
-  })
-
-  describe('with repeated transactions', () => {
-    const hashPayload = new PayloadBuilder<HashPayload>({ schema: HashSchema })
-      .fields({ hash: '3fc6fb2edd79e0d3f27c668a706cb48473d5f9e432e5462ae647702221a2c97a' })
-      .build()
-    beforeEach(async () => {})
-    it('when unique should allow transactions', async () => {
-      let newTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-      // NOTE: Cast to Account to allow loadPreviousHash to be called
-      const signer = await Account.random()
-      const transaction1 = await buildTransaction(TestChainId, [hashPayload], [], signer, 0, 100)
-      const transaction2 = await buildTransaction(TestChainId, [hashPayload], [], signer, 0, 100)
-      expect(transaction1[0]._hash).not.toEqual(transaction2[0]._hash)
-      for (const tx of [transaction1, transaction2]) {
-        const bundled = hydratedTransactionToPayloadBundle(tx)
-        await pendingBundledTransactionsArchivist.insert([bundled])
-        newTransactions.push(tx)
-      }
-      const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-      expect(result.length).toEqual(newTransactions.length)
-    })
-    it('when non-unique should filter duplicate transactions', async () => {
-      let newTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-      const previousHash = 'bb27dd470ccf91665d573a16b4f652a47b8a24686d1b44c189c1fa826cd3fef5'
-      // NOTE: Cast to Account to allow loadPreviousHash to be called
-      const signer = await Account.random() as Account
-      await signer.loadPreviousHash(previousHash)
-      const transaction1 = await buildTransaction(TestChainId, [hashPayload], [], signer, 0, 100)
-      await signer.loadPreviousHash(previousHash)
-      const transaction2 = await buildTransaction(TestChainId, [hashPayload], [], signer, 0, 100)
-      expect(transaction1[0]._hash).toEqual(transaction2[0]._hash)
-      for (const tx of [transaction1, transaction2]) {
-        const bundled = hydratedTransactionToPayloadBundle(tx)
-        await pendingBundledTransactionsArchivist.insert([bundled])
-        newTransactions.push(tx)
-      }
-      const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-      expect(result.length).toEqual(newTransactions.length / 2)
-    })
-  })
-
-  describe('with expiring transactions', () => {
-    const insertTransaction = async (nbf: number, exp: number) => {
-      const newTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-      const signer = await Account.random()
-      const hashPayload = new PayloadBuilder<HashPayload>({ schema: HashSchema })
-        .fields({ hash: head._hash })
-        .build()
-      const tx = await buildRandomTransaction(TestChainId, [hashPayload], signer, nbf, exp)
-      const bundled = hydratedTransactionToPayloadBundle(tx)
-      await pendingBundledTransactionsArchivist.insert([bundled])
-      newTransactions.push(tx)
-      await delay(2)
-      return newTransactions
-    }
-    describe('transaction nbf', () => {
-      describe('is included', () => {
-        it('when equal to previous block', async () => {
-          const nbf = head.block - 1
-          const exp = head.block + 3
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(newTransactions.length)
-        })
-        it('when equal to current block', async () => {
-          const nbf = head.block
-          const exp = head.block + 3
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(newTransactions.length)
-        })
-        it('when equal to next block', async () => {
-          const nbf = head.block + 1
-          const exp = head.block + 3
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(newTransactions.length)
-        })
-      })
-      describe('is excluded', () => {
-        it('when beyond next block', async () => {
-          const nbf = head.block + 2
-          const exp = head.block + 3
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(0)
-        })
-      })
-    })
-    describe('transaction exp', () => {
-      describe('is excluded', () => {
-        it('when equal to previous block', async () => {
-          const nbf = head.block - 3
-          const exp = head.block - 1
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(0)
-        })
-        it('when equal to current block', async () => {
-          const nbf = head.block - 3
-          const exp = head.block
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(0)
-        })
-      })
-      describe('is included', () => {
-        it('when equal to next block', async () => {
-          const nbf = head.block - 3
-          const exp = head.block + 1
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(newTransactions.length)
-        })
-        it('when beyond next block', async () => {
-          const nbf = head.block - 3
-          const exp = head.block + 3
-          const newTransactions = await insertTransaction(nbf, exp)
-          const result = await sut.getPendingTransactions(head._hash, newTransactions.length)
-          expect(result.length).toEqual(newTransactions.length)
-        })
-      })
-    })
-  })
-
-  describe('with pending and rejected transactions', () => {
-    let rejectedTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-    let newTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-    beforeEach(async () => {
-      for (let index = 0; index < 5; index++) {
-        const tx = await buildRandomTransaction(TestChainId)
-        rejectedTransactions.push(tx)
-        await delay(2)
-      }
-      await pendingBundledTransactionsArchivist.insert(rejectedTransactions.map(hydratedTransactionToPayloadBundle))
-      for (let index = 0; index < 5; index++) {
-        const tx = await buildRandomTransaction(TestChainId)
-        newTransactions.push(tx)
-        await delay(2)
-      }
-      await pendingBundledTransactionsArchivist.insert(newTransactions.map(hydratedTransactionToPayloadBundle))
-      await rejectedTransactionsArchivist.insert(flattenHydratedTransactions(rejectedTransactions))
-    })
-    it('should remove rejected transactions from pending', async () => {
-      const result = await sut.getPendingTransactions(head._hash, newTransactions.length + rejectedTransactions.length)
-      expect(result.length).toEqual(newTransactions.length)
-    })
-  })
-
-  describe('with invalid transactions in mempool', () => {
-    beforeEach(async () => {
-      const incorrectChainId = assertEx(asAddress('1234567890abcdef1234567890abcdef12345678'))
-      const invalidTransactions: SignedHydratedTransactionWithStorageMeta[] = [await buildRandomTransaction(incorrectChainId)]
-      const pending = invalidTransactions.map(hydratedTransactionToPayloadBundle)
-      await pendingBundledTransactionsArchivist.insert(pending)
-    })
-    it('should remove invalid transactions from pending', async () => {
-      const result = await sut.getPendingTransactions(head._hash, 20)
-      expect(result.length).toEqual(0)
-    })
-  })
-})

package/src/PendingTransactions/spec/bundledPayloadToHydratedTransaction.spec.ts

@@ -1,35 +0,0 @@
-import { buildRandomTransaction, TestChainId } from '@xyo-network/chain-protocol'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { HashPayload } from '@xyo-network/xl1-protocol'
-import { HashSchema } from '@xyo-network/xl1-protocol'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { bundledPayloadToHydratedTransaction } from '../bundledPayloadToHydratedTransaction.ts'
-import { hydratedTransactionToPayloadBundle } from '../hydratedTransactionToPayloadBundle.ts'
-
-describe('bundledPayloadToHydratedTransaction', () => {
-  it('creates a hydrated transaction from valid payload bundle', async () => {
-    // Create a minimal Transaction
-    const hashPayload = new PayloadBuilder<HashPayload>({ schema: HashSchema })
-      .fields({ hash: '3fc6fb2edd79e0d3f27c668a706cb48473d5f9e432e5462ae647702221a2c97a' })
-      .build()
-    const payloads = [hashPayload]
-    const tx = await buildRandomTransaction(TestChainId, payloads)
-
-    // Create bundle
-    const bundle = await PayloadBuilder.addStorageMeta(hydratedTransactionToPayloadBundle(tx))
-
-    // Act
-    const result = await bundledPayloadToHydratedTransaction(bundle)
-
-    // Assert
-    expect(result).toBeDefined()
-    expect(result?.[0]._hash).toEqual(tx[0]._hash)
-    expect(result?.[1].length).toEqual(payloads.length)
-    for (const payload of result?.[1] ?? []) {
-      expect(payload._hash).toEqual(await PayloadBuilder.hash(payload))
-    }
-  })
-})

package/src/PendingTransactions/spec/hydratedTransactionToPayloadBundle.spec.ts

@@ -1,28 +0,0 @@
-import { buildRandomTransaction, TestChainId } from '@xyo-network/chain-protocol'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { asOptionalPayloadBundle } from '@xyo-network/payload-model'
-import type { HashPayload } from '@xyo-network/xl1-protocol'
-import { HashSchema } from '@xyo-network/xl1-protocol'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { hydratedTransactionToPayloadBundle } from '../hydratedTransactionToPayloadBundle.ts'
-
-describe('hydratedTransactionToPayloadBundle', () => {
-  it('creates a payload bundle from a hydrated transaction', async () => {
-    // Create a minimal Transaction
-    const hashPayload = new PayloadBuilder<HashPayload>({ schema: HashSchema })
-      .fields({ hash: '3fc6fb2edd79e0d3f27c668a706cb48473d5f9e432e5462ae647702221a2c97a' })
-      .build()
-    const payloads = [hashPayload]
-    const tx = await buildRandomTransaction(TestChainId, payloads)
-
-    // Act
-    const bundle = hydratedTransactionToPayloadBundle(tx)
-
-    // Assert
-    expect(bundle).toBeDefined()
-    expect(asOptionalPayloadBundle(bundle)).toBeDefined()
-  })
-})