@xyo-network/chain-services 1.7.7 → 1.7.9

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

@@ -0,0 +1,274 @@
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import { asAddress } 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,
+  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, HydratedTransaction,
+} 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',
+      chainArchivist,
+      chainId,
+      config,
+      pendingBundledTransactionsArchivist,
+      rejectedTransactionsArchivist,
+    }
+    sut = await BasePendingTransactionsService.create(params)
+  })
+
+  describe('with pending transactions', () => {
+    let newTransactions: HydratedTransaction[] = []
+    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: HydratedTransaction[] = []
+    let newTransactions: HydratedTransaction[] = []
+    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: HydratedTransaction[] = []
+      // 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: HydratedTransaction[] = []
+      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: HydratedTransaction[] = []
+      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: HydratedTransaction[] = []
+    let newTransactions: HydratedTransaction[] = []
+    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: HydratedTransaction[] = [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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,28 @@
+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()
+  })
+})

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -4,7 +4,7 @@ import { creatable } from '@xylabs/creatable'
 import {
   Address, asAddress, Hash,
 } from '@xylabs/hex'
-import { isDefined, isUndefined } from '@xylabs/typeof'
+import { isUndefined } from '@xylabs/typeof'
 import { ArchivistInstance, ArchivistNextOptions } from '@xyo-network/archivist-model'
 import {
   analyzeChain, ChainStakeIntentAnalyzer,

package/xy.config.ts

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