@xyo-network/chain-services 1.7.7 → 1.7.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.7.7",
+  "version": "1.7.9",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -23,62 +23,64 @@
   "exports": {
     ".": {
       "types": "./dist/neutral/index.d.ts",
+      "source": "./src/index.ts",
       "default": "./dist/neutral/index.mjs"
     },
     "./package.json": "./package.json"
   },
   "module": "./dist/neutral/index.mjs",
+  "source": "./src/index.ts",
   "types": "./dist/neutral/index.d.ts",
-  "scripts": {
-    "deploy": "echo Deploy not allowed!",
-    "deploy3": "echo Deploy3 not allowed!"
-  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@xylabs/array": "^4.13.19",
-    "@xylabs/assert": "^4.13.19",
-    "@xylabs/creatable": "^4.13.19",
-    "@xylabs/decimal-precision": "^4.13.19",
-    "@xylabs/events": "^4.13.19",
-    "@xylabs/exists": "^4.13.19",
-    "@xylabs/forget": "^4.13.19",
-    "@xylabs/hex": "^4.13.19",
-    "@xylabs/promise": "^4.13.19",
-    "@xylabs/telemetry": "^4.13.19",
-    "@xylabs/typeof": "^4.13.19",
-    "@xyo-network/account-model": "^4.1.4",
-    "@xyo-network/archivist-memory": "^4.1.4",
-    "@xyo-network/archivist-model": "^4.1.4",
-    "@xyo-network/boundwitness-model": "^4.1.4",
-    "@xyo-network/boundwitness-validator": "^4.1.4",
-    "@xyo-network/boundwitness-wrapper": "^4.1.4",
-    "@xyo-network/chain-analyze": "^1.7.7",
-    "@xyo-network/chain-ethereum": "^1.7.7",
-    "@xyo-network/chain-modules": "^1.7.7",
-    "@xyo-network/chain-protocol": "^1.7.7",
-    "@xyo-network/chain-utils": "^1.7.7",
-    "@xyo-network/chain-validation": "^1.7.7",
-    "@xyo-network/chain-wrappers": "^1.7.7",
-    "@xyo-network/payload-builder": "^4.1.4",
-    "@xyo-network/payload-model": "^4.1.4",
+    "@xylabs/array": "^4.13.21",
+    "@xylabs/assert": "^4.13.21",
+    "@xylabs/creatable": "^4.13.21",
+    "@xylabs/decimal-precision": "^4.13.21",
+    "@xylabs/events": "^4.13.21",
+    "@xylabs/exists": "^4.13.21",
+    "@xylabs/forget": "^4.13.21",
+    "@xylabs/hex": "^4.13.21",
+    "@xylabs/promise": "^4.13.21",
+    "@xylabs/telemetry": "^4.13.21",
+    "@xylabs/typeof": "^4.13.21",
+    "@xyo-network/account-model": "^4.1.6",
+    "@xyo-network/archivist-memory": "^4.1.6",
+    "@xyo-network/archivist-model": "^4.1.6",
+    "@xyo-network/boundwitness-model": "^4.1.6",
+    "@xyo-network/boundwitness-validator": "^4.1.6",
+    "@xyo-network/boundwitness-wrapper": "^4.1.6",
+    "@xyo-network/chain-analyze": "^1.7.9",
+    "@xyo-network/chain-ethereum": "^1.7.9",
+    "@xyo-network/chain-modules": "^1.7.9",
+    "@xyo-network/chain-protocol": "^1.7.9",
+    "@xyo-network/chain-utils": "^1.7.9",
+    "@xyo-network/chain-validation": "^1.7.9",
+    "@xyo-network/chain-wrappers": "^1.7.9",
+    "@xyo-network/payload-builder": "^4.1.6",
+    "@xyo-network/payload-model": "^4.1.6",
     "@xyo-network/typechain": "^3.5.4",
-    "@xyo-network/xl1-protocol": "^1.7.5",
-    "@xyo-network/xl1-protocol-sdk": "^1.7.7",
+    "@xyo-network/xl1-protocol": "^1.7.10",
+    "@xyo-network/xl1-protocol-sdk": "^1.7.9",
     "async-mutex": "^0.5.0",
     "ethers": "6.15.0",
     "lru-cache": "^11.1.0"
   },
   "devDependencies": {
-    "@types/node": "^24.0.14",
-    "@xylabs/delay": "^4.13.19",
+    "@types/node": "^24.0.15",
+    "@xylabs/delay": "^4.13.21",
     "@xylabs/ts-scripts-yarn3": "^7.0.0",
     "@xylabs/tsconfig": "^7.0.0",
-    "@xylabs/vitest-extended": "^4.13.19",
-    "@xyo-network/account": "^4.1.4",
-    "@xyo-network/account-model": "^4.1.4",
-    "@xyo-network/chain-validation": "^1.7.7",
-    "@xyo-network/wallet": "^4.1.4",
-    "knip": "^5.61.3",
+    "@xylabs/vitest-extended": "^4.13.21",
+    "@xyo-network/account": "^4.1.6",
+    "@xyo-network/account-model": "^4.1.6",
+    "@xyo-network/chain-validation": "^1.7.9",
+    "@xyo-network/wallet": "^4.1.6",
+    "knip": "^5.62.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "vitest-mock-extended": "^3.1.0",

package/src/BlockProducer/BaseBlockProducerService.ts

@@ -215,7 +215,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
 
       // Build the block
       const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account])
-      this.logger?.warn(`buildBlock: ${block[0].block} with ${block[1].length} payloads`)
+      this.logger?.info(`buildBlock: ${block[0].block} with ${block[1].length} payloads`)
       const errors = await this.validateHydratedBlockState(block, this.chainId, { accountBalance: this.balanceService })
       if (errors.length > 0) {
         this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`)

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

@@ -0,0 +1,320 @@
+import '@xylabs/vitest-extended'
+
+import { filterAs } from '@xylabs/array'
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import type { Address } from '@xylabs/hex'
+import { asAddress, ZERO_HASH } from '@xylabs/hex'
+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, BlockRewardService, ElectionService,
+  HydratedBlock,
+  HydratedBlockStateValidationFunctionV2,
+  StakeIntentService,
+} from '@xyo-network/xl1-protocol'
+import {
+  asBlockBoundWitness,
+  asChainStakeIntent,
+  asTransactionBoundWitness,
+  HydratedBlockStateValidationError,
+} from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import {
+  flattenHydratedBlock, flattenHydratedTransaction, getDefaultConfig,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeAll, beforeEach, describe, expect, it,
+} from 'vitest'
+import { mock } from 'vitest-mock-extended'
+
+import { accountBalanceServiceFromArchivist } 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: Address = '1111111111111111111111111111111111111111'
+  let rewardService: BlockRewardService
+  let stakeIntentService: ReturnType<typeof mock<StakeIntentService>>
+  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',
+      chainArchivist: chainArchivist,
+      chainId,
+      config,
+      pendingBundledTransactionsArchivist,
+      rejectedTransactionsArchivist,
+    }
+    pendingTransactionsService = await BasePendingTransactionsService.create(BasePendingTransactionsServiceParams)
+    await addPendingTransactions(validPendingTransactions)
+
+    stakeIntentService = mock<StakeIntentService>()
+    stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([])
+    rewardService = await MemoryBlockRewardService.create()
+    const balanceService = await accountBalanceServiceFromArchivist(chainArchivist)
+    const params: BaseBlockProducerServiceParams = {
+      name: 'TestXyoBlockProducerParams',
+      account,
+      balanceService,
+      chainArchivist,
+      chainId,
+      config,
+      electionService,
+      pendingTransactionsService,
+      pendingBundledTransactionsArchivist,
+      rejectedTransactionsArchivist,
+      rewardAddress,
+      rewardService,
+      stakeIntentService,
+      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: HydratedBlockStateValidationFunctionV2 = async (
+            hydratedBlock: HydratedBlock,
+            chainId: Address,
+          ) => {
+            return rejectBlock ? [await Promise.resolve(new HydratedBlockStateValidationError(ZERO_HASH, chainId, hydratedBlock, 'Invalid block'))] : []
+          }
+          const balanceService = await accountBalanceServiceFromArchivist(chainArchivist)
+          const params: BaseBlockProducerServiceParams = {
+            name: 'TestXyoBlockProducerParams',
+            account,
+            balanceService,
+            chainArchivist,
+            chainId,
+            config,
+            electionService,
+            pendingBundledTransactionsArchivist,
+            pendingTransactionsService,
+            rejectedTransactionsArchivist,
+            rewardAddress,
+            rewardService,
+            stakeIntentService,
+            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()
+          expect(asBlockBoundWitness(block)).toBeDefined()
+          expect(transactionsAndData).toBeDefined()
+          expect(transactionsAndData).toBeArray()
+          const transactions = filterAs(assertEx(transactionsAndData), asTransactionBoundWitness)
+          expect(transactions).toBeArrayOfSize(newTransactionCount)
+        })
+      })
+    })
+    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

@@ -0,0 +1,72 @@
+import { assertEx } from '@xylabs/assert'
+import {
+  asAddress, hexToBigInt, toHex,
+} from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import { XYO_ZERO_ADDRESS } from '@xyo-network/chain-utils'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import {
+  defaultTransactionFees, type HydratedTransaction, type Transfer,
+} from '@xyo-network/xl1-protocol'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import { generateTransactionFeeTransfers } from '../generateTransactionFeeTransfers.ts'
+
+describe('generateTransactionTransfers', () => {
+  const testCases: HydratedTransaction[][] = [
+    [
+      [
+        {
+          schema: 'network.xyo.boundwitness',
+          addresses: ['39d22bed37f77bee0c056f648bde6efa489981c3'],
+          payload_hashes: ['65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8'],
+          payload_schemas: ['network.xyo.transfer'],
+          previous_hashes: [null],
+          $signatures: [
+            '0605878a92045bb752cc12066b585589b513cee652bf4bc36c19289495ccd3d3751a1202b5bfb334325c4c6a59a4a7dad7468739a8b4ffe07b6091317b16dc09',
+          ],
+          nbf: 2835,
+          exp: 3835,
+          fees: {
+            base: toHex(defaultTransactionFees.base),
+            gasLimit: toHex(defaultTransactionFees.gasLimit),
+            gasPrice: toHex(defaultTransactionFees.gasPrice),
+            priority: '00',
+          },
+          chain: 'a82920051db4fcbb804463440dd45e03f72442fd',
+          script: ['elevate|65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8'],
+          from: '39d22bed37f77bee0c056f648bde6efa489981c3',
+          _dataHash: '47be77303edd6073f82e9fff119107f1e173a08e7285e8e5f6e0c979d43e5b7d',
+          _hash: '1419062ddb266ff58515c4ffbc435ec482b6129d9e0c3c707fb7610c67215281',
+          _sequence: '00000196f46014770000000167215281',
+        },
+        [
+          {
+            schema: 'network.xyo.transfer',
+            epoch: 1_747_856_659_420,
+            from: '39d22bed37f77bee0c056f648bde6efa489981c3',
+            transfers: { db5df9c99e661500c95f2c933023ba693e5c1ae9: '056bc75e2d63100000' },
+            _dataHash: '65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8',
+            _hash: '65c64a5b2a2bf5aebc71255b64b36cc570dcd0d0539238757469d3772aef69c8',
+            _sequence: '00000196f4601477000000002aef69c8',
+          } 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)
+  })
+})