@xyo-network/chain-sdk 1.7.8 → 1.7.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-sdk",
-  "version": "1.7.8",
+  "version": "1.7.9",
   "description": "XYO Layer One SDK",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -24,21 +24,29 @@
     ".": {
       "browser": {
         "types": "./dist/browser/index-browser.d.ts",
+        "source": "./src/index-browser.ts",
         "default": "./dist/browser/index-browser.mjs"
       },
       "node": {
         "types": "./dist/node/index-node.d.ts",
+        "source": "./src/index-node.ts",
         "default": "./dist/node/index-node.mjs"
       },
       "neutral": {
         "types": "./dist/neutral/index-shared.d.ts",
+        "source": "./src/index-shared.ts",
         "default": "./dist/neutral/index-shared.mjs"
       }
     },
     "./package.json": "./package.json"
   },
   "module": "./dist/neutral/index-shared.mjs",
+  "source": "./src/index-shared.ts",
   "types": "./dist/neutral/index-shared.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "workspaces": [
     "packages/*"
   ],
@@ -52,36 +60,36 @@
     "@xylabs/assert": "^4.13.21",
     "@xylabs/delay": "^4.13.21",
     "@xylabs/hex": "^4.13.21",
-    "@xyo-network/account": "^4.1.5",
-    "@xyo-network/account-model": "^4.1.5",
-    "@xyo-network/chain-ethereum": "^1.7.8",
-    "@xyo-network/chain-modules": "^1.7.8",
-    "@xyo-network/chain-orchestration": "^1.7.8",
-    "@xyo-network/chain-protocol": "^1.7.8",
-    "@xyo-network/chain-services": "^1.7.8",
-    "@xyo-network/chain-utils": "^1.7.8",
-    "@xyo-network/chain-validation": "^1.7.8",
-    "@xyo-network/payload-builder": "^4.1.5",
+    "@xyo-network/account": "^4.1.6",
+    "@xyo-network/account-model": "^4.1.6",
+    "@xyo-network/chain-ethereum": "^1.7.9",
+    "@xyo-network/chain-modules": "^1.7.9",
+    "@xyo-network/chain-orchestration": "^1.7.9",
+    "@xyo-network/chain-protocol": "^1.7.9",
+    "@xyo-network/chain-services": "^1.7.9",
+    "@xyo-network/chain-utils": "^1.7.9",
+    "@xyo-network/chain-validation": "^1.7.9",
+    "@xyo-network/payload-builder": "^4.1.6",
     "@xyo-network/typechain": "^3.5.4",
-    "@xyo-network/wallet-model": "^4.1.5",
-    "@xyo-network/xl1-protocol": "^1.7.5",
-    "@xyo-network/xl1-protocol-sdk": "^1.7.8",
+    "@xyo-network/wallet-model": "^4.1.6",
+    "@xyo-network/xl1-protocol": "^1.7.10",
+    "@xyo-network/xl1-protocol-sdk": "^1.7.9",
     "ethers": "6.15.0"
   },
   "devDependencies": {
-    "@types/node": "^24.0.14",
+    "@types/node": "^24.0.15",
     "@xylabs/decimal-precision": "^4.13.21",
     "@xylabs/delay": "^4.13.21",
     "@xylabs/ts-scripts-yarn3": "^7.0.0",
     "@xylabs/tsconfig": "^7.0.0",
-    "@xyo-network/account": "^4.1.5",
-    "@xyo-network/account-model": "^4.1.5",
-    "@xyo-network/archivist-memory": "^4.1.5",
-    "@xyo-network/archivist-model": "^4.1.5",
-    "@xyo-network/boundwitness-builder": "^4.1.5",
-    "@xyo-network/chain-analyze": "^1.7.8",
-    "@xyo-network/payload-model": "^4.1.5",
-    "@xyo-network/wallet": "^4.1.5",
+    "@xyo-network/account": "^4.1.6",
+    "@xyo-network/account-model": "^4.1.6",
+    "@xyo-network/archivist-memory": "^4.1.6",
+    "@xyo-network/archivist-model": "^4.1.6",
+    "@xyo-network/boundwitness-builder": "^4.1.6",
+    "@xyo-network/chain-analyze": "^1.7.9",
+    "@xyo-network/payload-model": "^4.1.6",
+    "@xyo-network/wallet": "^4.1.6",
     "eslint": "^9.31.0",
     "knip": "^5.62.0",
     "typescript": "^5.8.3",

package/src/e2e/spec/ChainHeadSelector.spec.ts

@@ -0,0 +1,61 @@
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import { ChainHeadSelector } from '@xyo-network/chain-analyze'
+import { buildRandomChain } from '@xyo-network/chain-protocol'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { HydratedBlock } from '@xyo-network/xl1-protocol'
+import { flattenHydratedBlock } from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeEach,
+  describe, expect, it,
+} from 'vitest'
+
+describe('ChainHeadSelector', () => {
+  let SampleBlockChain: HydratedBlock[]
+  let SampleGenesisOnlyBlockChain: HydratedBlock[]
+  let producer: AccountInstance
+  let archivist: MemoryArchivist
+  beforeEach (async () => {
+    producer = await Account.random()
+    archivist = await MemoryArchivist.create({ account: 'random' })
+    SampleBlockChain = (await buildRandomChain(producer, 10))
+    SampleGenesisOnlyBlockChain = await buildRandomChain(producer, 1)
+  })
+  it('no producers', async () => {
+    expect(SampleBlockChain.length).toEqual(10)
+    await archivist.insert(SampleBlockChain.flatMap(block => flattenHydratedBlock(block)))
+    const selector = new ChainHeadSelector({ chainArchivist: archivist })
+    const bestHead = await selector.findBestHead()
+    expect(bestHead).toBeDefined()
+    expect(bestHead?.previous).toBeDefined()
+  })
+  it('only one producer', async () => {
+    await archivist.insert(SampleBlockChain.flatMap(block => flattenHydratedBlock(block)))
+    const selector = new ChainHeadSelector({ chainArchivist: archivist, activeProducers: [producer.address] })
+    const bestHead = await selector.findBestHead()
+    expect(bestHead).toBeDefined()
+    expect(bestHead?.previous === null).toBeFalsy()
+  })
+  it('only genesis block', async () => {
+    await archivist.insert(SampleGenesisOnlyBlockChain.flatMap(block => flattenHydratedBlock(block)))
+    const selector = new ChainHeadSelector({ chainArchivist: archivist, activeProducers: [producer.address] })
+    const bestHead = await selector.findBestHead()
+    expect(bestHead).toBeDefined()
+    expect(bestHead?.previous).toBeNull()
+  })
+  it('with finalization', async () => {
+    await archivist.insert(SampleBlockChain.flatMap(block => flattenHydratedBlock(block)))
+    const selector = new ChainHeadSelector({ chainArchivist: archivist, activeProducers: [producer.address] })
+    const bestHead = await selector.findBestHead()
+    if (bestHead) {
+      await selector.finalizeBlock(await PayloadBuilder.hash(bestHead))
+    }
+    const bestHead2 = await selector.findBestHead()
+    expect(bestHead).toBeDefined()
+    expect(bestHead2).toBeDefined()
+    if (bestHead && bestHead2) {
+      expect(await PayloadBuilder.hash(bestHead)).toBe(await PayloadBuilder.hash(bestHead2))
+    }
+  })
+})

package/src/e2e/spec/EvmBlockRewardService.spec.ts

@@ -0,0 +1,180 @@
+import type { ChildProcess } from 'node:child_process'
+
+import { assertEx } from '@xylabs/assert'
+import { toFixedPoint } from '@xylabs/decimal-precision'
+import { delay } from '@xylabs/delay'
+import { Account } from '@xyo-network/account'
+import {
+  createChainContract, createChainRewardsContract, getDefaultGasConfig,
+} from '@xyo-network/chain-ethereum'
+import type { EvmBlockRewardServiceParams } from '@xyo-network/chain-services'
+import { EvmBlockRewardService, EvmChainService } from '@xyo-network/chain-services'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import { getDefaultConfig } from '@xyo-network/xl1-protocol-sdk'
+import type { ContractRunner } from 'ethers/providers'
+import { JsonRpcProvider } from 'ethers/providers'
+import { Wallet } from 'ethers/wallet'
+import {
+  afterAll,
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import { startGanache, stopGanache } from '../../test/index.ts'
+
+const ganachePort = 8565
+const testPhrase = 'edit hill neutral usage share kite knee abandon slim open lottery abandon'
+
+// eslint-disable-next-line max-statements
+describe('EvmBlockRewardService', () => {
+  const genesisReward = toFixedPoint(20_000_000_000n)
+  const initialStepReward = toFixedPoint(1000n)
+  const stepSize = 1_000_000n
+  const minRewardPerBlock = toFixedPoint(30n)
+  const config = getDefaultConfig()
+
+  let service: EvmBlockRewardService
+  let accountPerson: WalletInstance
+  let accountPerson2: WalletInstance
+  let walletPerson: WalletInstance
+  let ganacheProcess: ChildProcess
+  let ethWalletPerson: Wallet
+  let ethWalletPerson2: Wallet
+  let provider: JsonRpcProvider
+  let provider2: JsonRpcProvider
+
+  beforeAll(async () => {
+    ganacheProcess = await startGanache(ganachePort, testPhrase)
+    walletPerson = await HDWallet.fromPhrase(testPhrase, "m/44'/60'/0'/0")
+    accountPerson = await walletPerson.derivePath("m/44'/60'/0'/0/0")
+    accountPerson2 = await walletPerson.derivePath("m/44'/60'/0'/0/1")
+    provider = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+    ethWalletPerson = new Wallet(accountPerson.privateKey, provider)
+    provider2 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+    ethWalletPerson2 = new Wallet(accountPerson2.privateKey, provider2)
+    const rewardsContract = await createChainRewardsContract(ethWalletPerson, genesisReward, getDefaultGasConfig())
+    const tokenAddress = '0x01'
+    const genesisBlockHash = '0x01'
+    const stakeContract = await createChainContract(ethWalletPerson2, tokenAddress, genesisBlockHash, rewardsContract, 1n, getDefaultGasConfig())
+    const id = stakeContract
+    const account = await Account.random()
+    const privateKey = assertEx(account.private?.hex, () => 'Error: Account does not have a private key')
+    const runner: ContractRunner = new Wallet(privateKey, provider)
+
+    const chainService = await EvmChainService.create({ id, runner })
+    const params: EvmBlockRewardServiceParams = {
+      account,
+      chainService,
+      config,
+      name: 'EvmBlockRewardService',
+      provider,
+    }
+    service = await EvmBlockRewardService.create(params)
+  }, 40_000)
+
+  afterAll(async () => {
+    await delay(1000)
+    stopGanache(ganacheProcess)
+  }, 20_000)
+
+  it('blocks 0 and 1', async () => {
+    expect(await service.getRewardForBlock(0n)).toBe(genesisReward)
+    expect(await service.getRewardForBlock(10n)).toBe(initialStepReward)
+  })
+
+  it('last block in step 1', async () => {
+    expect(await service.getRewardForBlock(stepSize - 1n)).toBe(initialStepReward)
+  })
+
+  it('first blocks in step 2', async () => {
+    expect(await service.getRewardForBlock(stepSize)).toBe(950_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 2', async () => {
+    expect(await service.getRewardForBlock(stepSize * 2n - 1n)).toBe(950_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 3', async () => {
+    expect(await service.getRewardForBlock(stepSize * 2n)).toBe(902_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 5', async () => {
+    expect(await service.getRewardForBlock(stepSize * 4n)).toBe(813_000_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 4n + 1n)).toBe(813_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 5', async () => {
+    expect(await service.getRewardForBlock(stepSize * 5n - 1n)).toBe(813_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 10', async () => {
+    expect(await service.getRewardForBlock(stepSize * 9n)).toBe(627_000_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 9n + 1n)).toBe(627_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 10', async () => {
+    expect(await service.getRewardForBlock(stepSize * 10n - 1n)).toBe(627_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 20', async () => {
+    expect(await service.getRewardForBlock(stepSize * 19n)).toBe(372_000_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 19n + 1n)).toBe(372_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 20', async () => {
+    expect(await service.getRewardForBlock(stepSize * 20n - 1n)).toBe(372_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 30', async () => {
+    expect(await service.getRewardForBlock(stepSize * 29n)).toBe(219_000_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 29n + 1n)).toBe(219_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 30', async () => {
+    expect(await service.getRewardForBlock(stepSize * 30n - 1n)).toBe(219_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 40', async () => {
+    expect(await service.getRewardForBlock(stepSize * 39n)).toBe(128_000_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 39n + 1n)).toBe(128_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 40', async () => {
+    expect(await service.getRewardForBlock(stepSize * 40n - 1n)).toBe(128_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 44', async () => {
+    expect(await service.getRewardForBlock(stepSize * 43n)).toBe(102_000_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 43n + 1n)).toBe(102_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 44', async () => {
+    expect(await service.getRewardForBlock(stepSize * 44n - 1n)).toBe(102_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 64', async () => {
+    expect(await service.getRewardForBlock(stepSize * 63n)).toBe(31_000_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 63n + 1n)).toBe(31_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 68', async () => {
+    expect(await service.getRewardForBlock(stepSize * 64n)).toBe(minRewardPerBlock)
+    expect(await service.getRewardForBlock(stepSize * 64n + 1n)).toBe(minRewardPerBlock)
+  })
+
+  it('first blocks in step 80', async () => {
+    expect(await service.getRewardForBlock(stepSize * 80n)).toBe(minRewardPerBlock)
+    expect(await service.getRewardForBlock(stepSize * 80n + 1n)).toBe(minRewardPerBlock)
+  })
+
+  it('first blocks in step 200', async () => {
+    expect(await service.getRewardForBlock(stepSize * 200n)).toBe(minRewardPerBlock)
+    expect(await service.getRewardForBlock(stepSize * 200n + 1n)).toBe(minRewardPerBlock)
+  })
+
+  it('first blocks in step 2000', async () => {
+    expect(await service.getRewardForBlock(stepSize * 2000n)).toBe(minRewardPerBlock)
+    expect(await service.getRewardForBlock(stepSize * 2000n + 1n)).toBe(minRewardPerBlock)
+  })
+})

package/src/e2e/spec/EvmChainService.spec.ts

@@ -0,0 +1,131 @@
+import type { ChildProcess } from 'node:child_process'
+
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import { asAddress } from '@xylabs/hex'
+import type { AccountInstance } from '@xyo-network/account-model'
+import { createChain, toEthAddress } from '@xyo-network/chain-ethereum'
+import { EvmChainService } from '@xyo-network/chain-services'
+import { XYO_ZERO_ADDRESS } from '@xyo-network/chain-utils'
+import type { BurnableErc20 } from '@xyo-network/typechain'
+import { BurnableErc20__factory as Erc20Factory, StakedXyoChain__factory as StakedXyoChainFactory } from '@xyo-network/typechain'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { ContractRunner } from 'ethers/providers'
+import { JsonRpcProvider } from 'ethers/providers'
+import { parseUnits } from 'ethers/utils'
+import { Wallet } from 'ethers/wallet'
+import {
+  afterAll, beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { startGanache, stopGanache } from '../../test/index.ts'
+
+const ganachePort = 8545
+const testPhrase = 'edit hill neutral usage share kite knee abandon slim open lottery abandon'
+
+const gasConfig = () => {
+  return {
+    gasLimit: 2_000_000, // Set the gas limit
+    gasPrice: parseUnits('100', 'gwei'),
+  }
+}
+
+describe('EvmContractChainStake', () => {
+  let account0: WalletInstance
+  let account1: WalletInstance
+  let walletPerson: WalletInstance
+  let initialProducerAccount: AccountInstance
+  let ganacheProcess: ChildProcess
+  let ethWalletPerson0: Wallet
+  let ethWalletPerson1: Wallet
+  let provider0: JsonRpcProvider
+  let provider1: JsonRpcProvider
+
+  beforeAll(async () => {
+    ganacheProcess = await startGanache(ganachePort, testPhrase)
+    walletPerson = await HDWallet.fromPhrase(testPhrase, "m/44'/60'/0'/0")
+    initialProducerAccount = await HDWallet.fromPhrase(testPhrase, "m/44'/60'/1'/0")
+    account0 = await walletPerson.derivePath("m/44'/60'/0'/0/0")
+    account1 = await walletPerson.derivePath("m/44'/60'/0'/0/1")
+    provider0 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+    ethWalletPerson0 = new Wallet(account0.privateKey, provider0)
+    provider1 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+    ethWalletPerson1 = new Wallet(account1.privateKey, provider1)
+  }, 20_000)
+
+  afterAll(async () => {
+    await delay(1000)
+    stopGanache(ganacheProcess)
+  }, 20_000)
+
+  describe.sequential('Create Fresh Chain', () => {
+    let erc20Contract: BurnableErc20
+    let erc20Address: string
+    let erc20ContractPerson0: BurnableErc20
+    let xyoChainContractAddress: string
+    let erc20ContractPerson1: BurnableErc20
+
+    it('Create Erc20', async () => {
+      const erc20 = new Erc20Factory(ethWalletPerson0)
+      erc20Contract = await (await erc20.deploy('Test Token', 'TST', parseUnits('1000000', 18), gasConfig())).waitForDeployment()
+      erc20Address = await erc20Contract.getAddress()
+      expect(erc20Address).toBeDefined()
+      erc20ContractPerson0 = Erc20Factory.connect(erc20Address, ethWalletPerson0)
+      const balance = await erc20ContractPerson0.balanceOf(ethWalletPerson0.address)
+      expect(balance).toBe(parseUnits('1000000', 18))
+    })
+
+    it('Transfer Tokens', async () => {
+      const transfer = await (await erc20ContractPerson0.transfer(ethWalletPerson1.address, parseUnits('1000', 18), gasConfig())).wait()
+      expect(transfer).toBeDefined()
+      erc20ContractPerson1 = Erc20Factory.connect(erc20Address, ethWalletPerson1)
+      const balance = await erc20ContractPerson1.balanceOf(ethWalletPerson1.address)
+      expect(balance).toBe(parseUnits('1000', 18))
+    })
+
+    it('Create Chain Contract', async () => {
+      // Create Chain Contract
+      const result = await (createChain(
+        ethWalletPerson0, // signer
+        toEthAddress(erc20Address), // stakingTokenAddress
+        initialProducerAccount, // initialProducer
+        null,
+        0n,
+        XYO_ZERO_ADDRESS,
+        50_000n,
+        gasConfig(),
+      ))
+
+      xyoChainContractAddress = toEthAddress(result[0])
+
+      const xyoChainPerson0 = StakedXyoChainFactory.connect(xyoChainContractAddress)
+      expect(xyoChainPerson0).toBeDefined()
+      const xyoChainPerson1 = StakedXyoChainFactory.connect(xyoChainContractAddress, ethWalletPerson1)
+      const xyoChainPerson1Address = await xyoChainPerson1.getAddress()
+      expect(xyoChainPerson1Address).toBeDefined()
+    }, 1_000_000)
+
+    it('Approve Stake Chain Address', async () => {
+      const approveResultTx = await (await erc20ContractPerson1.approve(xyoChainContractAddress, parseUnits('100', 18), gasConfig())).wait()
+      expect(approveResultTx).toBeDefined()
+    })
+
+    it('Stake Chain Contract', async () => {
+      const address = assertEx(asAddress(xyoChainContractAddress))
+      const xyoChainPerson1 = await EvmChainService.create({
+        id: address,
+        runner: ethWalletPerson1 as ContractRunner,
+      })
+      const stakeResult = await xyoChainPerson1.addStake(await ethWalletPerson1.getAddress(), parseUnits('50', 18))
+      expect(stakeResult).toBeTruthy()
+    })
+
+    it('Read Stake', async () => {
+      const address = assertEx(asAddress(xyoChainContractAddress))
+      const xyoChainPerson0 = await EvmChainService.create({ id: address, runner: ethWalletPerson0 as ContractRunner })
+      const stakeByAddressResult = await xyoChainPerson0.activeByAddressStaked(await ethWalletPerson1.getAddress())
+      expect(stakeByAddressResult).toBe(parseUnits('50', 18))
+    })
+  }, 10_000)
+}, 10_000)

package/src/e2e/spec/XyoBlockRewardService.spec.ts

@@ -0,0 +1,77 @@
+import { toFixedPoint } from '@xylabs/decimal-precision'
+import { MemoryBlockRewardService } from '@xyo-network/chain-services'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+describe('XyoBlockRewardService', async () => {
+  const creatorReward = toFixedPoint(20_000_000_000n)
+  const initialStepReward = toFixedPoint(3000n)
+  const stepSize = 1_000_000n
+  const minRewardPerBlock = toFixedPoint(30n)
+  const service = await MemoryBlockRewardService.create({
+    initialStepReward, stepSize, creatorReward, minRewardPerBlock,
+  })
+
+  it('blocks 0 and 1', async () => {
+    expect(await service.getRewardForBlock(0n)).toBe(creatorReward)
+    expect(await service.getRewardForBlock(10n)).toBe(initialStepReward)
+  })
+
+  it('last block in step 1', async () => {
+    expect(await service.getRewardForBlock(stepSize - 1n)).toBe(initialStepReward)
+  })
+
+  it('first blocks in step 2', async () => {
+    expect(await service.getRewardForBlock(stepSize)).toBe(2_700_000_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 2', async () => {
+    expect(await service.getRewardForBlock(stepSize * 2n - 1n)).toBe(2_700_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 3', async () => {
+    expect(await service.getRewardForBlock(stepSize * 2n)).toBe(2_430_000_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 5', async () => {
+    expect(await service.getRewardForBlock(stepSize * 4n)).toBe(1_968_300_000_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 4n + 1n)).toBe(1_968_300_000_000_000_000_000n)
+  })
+
+  it('last blocks in step 5', async () => {
+    expect(await service.getRewardForBlock(stepSize * 5n - 1n)).toBe(1_968_300_000_000_000_000_000n)
+  })
+
+  it('first blocks in step 10', async () => {
+    expect(await service.getRewardForBlock(stepSize * 9n)).toBe(1_162_261_467_000_000_000_000n)
+    expect(await service.getRewardForBlock(stepSize * 9n + 1n)).toBe(1_162_261_467_000_000_000_000n)
+  })
+
+  it('last blocks in step 10', async () => {
+    expect(await service.getRewardForBlock(stepSize * 10n - 1n)).toBe(1_162_261_467_000_000_000_000n)
+  })
+
+  it('first blocks in step 40', async () => {
+    expect(await service.getRewardForBlock(stepSize * 39n)).toBe(49_269_609_804_781_974_438n)
+    expect(await service.getRewardForBlock(stepSize * 39n + 1n)).toBe(49_269_609_804_781_974_438n)
+  })
+
+  it('last blocks in step 40', async () => {
+    expect(await service.getRewardForBlock(stepSize * 40n - 1n)).toBe(49_269_609_804_781_974_438n)
+  })
+
+  it('first blocks in step 44', async () => {
+    expect(await service.getRewardForBlock(stepSize * 43n)).toBe(32_325_790_992_917_453_429n)
+    expect(await service.getRewardForBlock(stepSize * 43n + 1n)).toBe(32_325_790_992_917_453_429n)
+  })
+
+  it('last blocks in step 44', async () => {
+    expect(await service.getRewardForBlock(stepSize * 44n - 1n)).toBe(32_325_790_992_917_453_429n)
+  })
+
+  it('first blocks in step 54', async () => {
+    expect(await service.getRewardForBlock(stepSize * 53n)).toBe(minRewardPerBlock)
+    expect(await service.getRewardForBlock(stepSize * 53n + 1n)).toBe(minRewardPerBlock)
+  })
+})

package/src/e2e/spec/send-xl1.spec.ts

@@ -0,0 +1,98 @@
+import { assertEx } from '@xylabs/assert'
+import { toFixedPoint } from '@xylabs/decimal-precision'
+import type { Address, Hash } from '@xylabs/hex'
+import { toHex } 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 { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
+import {
+  analyzeChain, BalanceAnalyzer, isChainSummaryBalances,
+} from '@xyo-network/chain-analyze'
+import {
+  buildGenesisBlock, buildNextBlock, buildRandomTransaction,
+} from '@xyo-network/chain-protocol'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
+import type { BlockBoundWitness, Transfer } from '@xyo-network/xl1-protocol'
+import { TransferSchema } from '@xyo-network/xl1-protocol'
+import { flattenHydratedBlock } from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+const balancesFromHead = async (head: Hash, archivist: ArchivistInstance) => {
+  const { balances } = assertEx((await analyzeChain(
+    archivist,
+    [new BalanceAnalyzer()],
+    head,
+  )).find(isChainSummaryBalances), () => 'ChainSummaryBalances not found')
+  return balances
+}
+
+describe.sequential('Send XL1', () => {
+  let archivist: ArchivistInstance
+  let chainId: Address
+  let previousBlock: WithStorageMeta<BlockBoundWitness>
+  let txAccount1: AccountInstance
+  let txAccount2: AccountInstance
+  let blockAccount1: AccountInstance
+  let blockAccount2: AccountInstance
+  beforeAll(async () => {
+    // make a fake chainId using a random address
+    chainId = (await Account.random()).address
+    archivist = await MemoryArchivist.create({ account: 'random' })
+  })
+  it('Get Initial Balances', async () => {
+    blockAccount1 = await Account.random()
+    txAccount1 = await Account.random()
+    const firstHydratedTx = await buildRandomTransaction(chainId, undefined, txAccount1)
+    const firstBlock = await buildGenesisBlock(chainId, [firstHydratedTx], [], [blockAccount1], blockAccount1.address, toFixedPoint(3000n))
+    expect(firstBlock[0].block).toEqual(0)
+    await archivist.insert(flattenHydratedBlock(firstBlock))
+    previousBlock = firstBlock[0]
+    const balances = await balancesFromHead(previousBlock._hash, archivist)
+    expect(balances[blockAccount1.address]).toEqual({ positive: toHex(toFixedPoint(3000n)) })
+  }, 10_000)
+  it('Do a transfer', async () => {
+    blockAccount2 = await Account.random()
+    const receiveAccount = await Account.random()
+    txAccount2 = await Account.random()
+    const transferPayload: Transfer = {
+      from: txAccount2.address,
+      epoch: Date.now(),
+      schema: TransferSchema,
+      transfers: { [receiveAccount.address]: toHex(toFixedPoint(1n)) },
+    }
+    const [innerBw] = await new BoundWitnessBuilder().payload({ schema: 'network.xyo.test', nonce: 2 } as Payload).signer(await Account.random()).build()
+    const secondHydratedTx = await buildRandomTransaction(chainId, [transferPayload, innerBw], txAccount2)
+    const secondBlock = await buildNextBlock(previousBlock, [secondHydratedTx], [], [blockAccount2], blockAccount2.address, toFixedPoint(3000n))
+    expect(secondBlock[0].block).toEqual(1)
+    await archivist.insert([...flattenHydratedBlock(secondBlock)])
+    previousBlock = secondBlock[0]
+    const balanceChanges = await balancesFromHead(await PayloadBuilder.hash(secondBlock[0]), archivist)
+    expect(balanceChanges[blockAccount1.address]).toEqual({ positive: toHex(toFixedPoint(3000n)) })
+    expect(balanceChanges[blockAccount2.address]).toEqual({ positive: toHex(toFixedPoint(3000n)) })
+    expect(balanceChanges[receiveAccount.address]).toEqual({ positive: toHex(toFixedPoint(1n)) })
+  }, 10_000)
+})
+
+/*
+
+# Send XL1
+
+The signer of a boundwitness that contains a transfer payload will have their balance reduced by the amount of the transfer,
+and the receiver will have their balance increased by the amount of the transfer.
+
+The gas that is specified in the transfer payload will be deducted from the signer's balance and will be added to the block builder's balance.
+
+The goal is for the block builder to only have to validate the transfers that are directly in the transactions that are being added to the block.
+This means that the builder will only accept transfers from accounts that have matching vouchers, and will only accept transfers that are valid.
+
+If an unknown account wants to send xl1 to another account, they must get a voucher from a bank that will allow them to send the xl1.
+
+Do we need two payloads for this, or do we need one payload that has a list of transfers?
+
+*/

package/src/spec/RequiredBalance.spec.ts

@@ -0,0 +1,44 @@
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import { buildRandomChain } from '@xyo-network/chain-protocol'
+import { accountBalanceServiceFromArchivist } from '@xyo-network/chain-services'
+import { RequiredBalanceBlockStateValidator } from '@xyo-network/chain-validation'
+import { flattenHydratedBlock } from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeEach,
+  describe, expect, it,
+} from 'vitest'
+
+describe('RequiredBalanceBlockStateValidator', () => {
+  let blockProducer: AccountInstance
+  let archivist: MemoryArchivist
+  const chainId = 'a82920051db4fcbb804463440dd45e03f72442fd'
+  beforeEach(async () => {
+    archivist = await MemoryArchivist.create({ account: 'random' })
+    blockProducer = await Account.random()
+  })
+  it('does not validate block level transfers', async () => {
+    expect(await Promise.resolve()).toBeUndefined()
+    const chain = await buildRandomChain(blockProducer, 2)
+    await archivist.insert(flattenHydratedBlock(chain[0]))
+    const hydratedBlock = chain[1]
+    const accountBalance = await accountBalanceServiceFromArchivist(archivist)
+
+    // Mock the account balance service to return a balance of 1 ETH for the block producer
+    const result = await RequiredBalanceBlockStateValidator(hydratedBlock, chainId, { accountBalance })
+    expect(result).toEqual([])
+  })
+
+  it('returns no errors when required balances are met', async () => {
+    expect(await Promise.resolve()).toBeUndefined()
+  })
+
+  it('returns an error when required balance is not met', async () => {
+    expect(await Promise.resolve()).toBeUndefined()
+  })
+
+  it('returns error when block has no previous hash (first block)', async () => {
+    expect(await Promise.resolve()).toBeUndefined()
+  })
+})

package/xy.config.ts

@@ -1,11 +0,0 @@
-import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
-const config: XyTsupConfig = {
-  compile: {
-    entryMode: 'custom',
-    browser: { src: { entry: ['index-browser.ts'] } },
-    node: { src: { entry: ['index-node.ts'] } },
-    neutral: { src: { entry: ['index-shared.ts'] } },
-  },
-}
-
-export default config