@xyo-network/diviner-payload-pointer-memory 4.3.0 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/diviner-payload-pointer-memory",
-  "version": "4.3.0",
+  "version": "5.0.0",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -28,41 +28,45 @@
   },
   "module": "dist/neutral/index.mjs",
   "types": "dist/neutral/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
-    "@xylabs/assert": "^4.15.0",
-    "@xylabs/exists": "^4.15.0",
-    "@xyo-network/boundwitness-wrapper": "^4.3.0",
-    "@xyo-network/diviner-abstract": "^4.3.0",
-    "@xyo-network/diviner-boundwitness-model": "^4.3.0",
-    "@xyo-network/diviner-model": "^4.3.0",
-    "@xyo-network/diviner-payload-model": "^4.3.0",
-    "@xyo-network/diviner-payload-pointer-model": "^4.3.0",
-    "@xyo-network/payload-model": "^4.3.0",
-    "@xyo-network/payload-wrapper": "^4.3.0"
+    "@xylabs/assert": "^5.0.0",
+    "@xylabs/exists": "^5.0.0",
+    "@xyo-network/boundwitness-wrapper": "^5.0.0",
+    "@xyo-network/diviner-abstract": "^5.0.0",
+    "@xyo-network/diviner-boundwitness-model": "^5.0.0",
+    "@xyo-network/diviner-model": "^5.0.0",
+    "@xyo-network/diviner-payload-model": "^5.0.0",
+    "@xyo-network/diviner-payload-pointer-model": "^5.0.0",
+    "@xyo-network/payload-model": "^5.0.0",
+    "@xyo-network/payload-wrapper": "^5.0.0"
   },
   "devDependencies": {
     "@types/uuid": "^10.0.0",
-    "@xylabs/delay": "^4.15.0",
-    "@xylabs/hex": "^4.15.0",
-    "@xylabs/ts-scripts-yarn3": "^7.0.1",
-    "@xylabs/tsconfig": "^7.0.1",
-    "@xylabs/vitest-extended": "^4.15.0",
-    "@xyo-network/account": "^4.3.0",
-    "@xyo-network/account-model": "^4.3.0",
-    "@xyo-network/archivist-memory": "^4.3.0",
-    "@xyo-network/archivist-model": "^4.3.0",
-    "@xyo-network/boundwitness-builder": "^4.3.0",
-    "@xyo-network/boundwitness-model": "^4.3.0",
-    "@xyo-network/diviner-boundwitness-abstract": "^4.3.0",
-    "@xyo-network/diviner-boundwitness-memory": "^4.3.0",
-    "@xyo-network/diviner-payload-abstract": "^4.3.0",
-    "@xyo-network/diviner-payload-generic": "^4.3.0",
-    "@xyo-network/diviner-payload-memory": "^4.3.0",
-    "@xyo-network/node-memory": "^4.3.0",
-    "@xyo-network/node-model": "^4.3.0",
-    "@xyo-network/payload-builder": "^4.3.0",
-    "@xyo-network/wallet": "^4.3.0",
-    "@xyo-network/wallet-model": "^4.3.0",
+    "@xylabs/delay": "^5.0.0",
+    "@xylabs/hex": "^5.0.0",
+    "@xylabs/ts-scripts-yarn3": "^7.0.2",
+    "@xylabs/tsconfig": "^7.0.2",
+    "@xylabs/vitest-extended": "^5.0.0",
+    "@xyo-network/account": "^5.0.0",
+    "@xyo-network/account-model": "^5.0.0",
+    "@xyo-network/archivist-memory": "^5.0.0",
+    "@xyo-network/archivist-model": "^5.0.0",
+    "@xyo-network/boundwitness-builder": "^5.0.0",
+    "@xyo-network/boundwitness-model": "^5.0.0",
+    "@xyo-network/diviner-boundwitness-abstract": "^5.0.0",
+    "@xyo-network/diviner-boundwitness-memory": "^5.0.0",
+    "@xyo-network/diviner-payload-abstract": "^5.0.0",
+    "@xyo-network/diviner-payload-generic": "^5.0.0",
+    "@xyo-network/diviner-payload-memory": "^5.0.0",
+    "@xyo-network/node-memory": "^5.0.0",
+    "@xyo-network/node-model": "^5.0.0",
+    "@xyo-network/payload-builder": "^5.0.0",
+    "@xyo-network/wallet": "^5.0.0",
+    "@xyo-network/wallet-model": "^5.0.0",
     "typescript": "^5.8.3",
     "uuid": "^11.1.0",
     "vitest": "^3.2.4"

package/src/spec/Diviner.payloadPointer.address.spec.ts

@@ -0,0 +1,94 @@
+import '@xylabs/vitest-extended'
+
+import { delay } from '@xylabs/delay'
+import { Account } from '@xyo-network/account'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import type { PayloadPointerDiviner } from '../Diviner.ts'
+import {
+  createPointer,
+  getArchivist,
+  getNewBoundWitness,
+  getPayloadPointerDiviner,
+  getTestNode,
+  insertBlock,
+  insertPayload,
+} from './testUtil/index.ts'
+
+describe('PayloadPointerDiviner', () => {
+  describe('with rules for [address]', () => {
+    const accountA = Account.random()
+    const accountB = Account.random()
+    const accountC = Account.random()
+    const accountD = Account.random()
+    const payloads: Payload[] = []
+    let node: NodeInstance
+    let archivist: ArchivistInstance
+    let sut: PayloadPointerDiviner
+    beforeAll(async () => {
+      node = await getTestNode()
+      archivist = await getArchivist(node)
+      sut = await getPayloadPointerDiviner(node)
+      const [bwA, payloadsA] = await getNewBoundWitness([await accountA])
+      const [bwB, payloadsB] = await getNewBoundWitness([await accountB])
+      const [bwC, payloadsC] = await getNewBoundWitness([await accountC])
+      const [bwD, payloadsD] = await getNewBoundWitness([await accountD])
+      const [bwE, payloadsE] = await getNewBoundWitness([await accountC, await accountD])
+      const [bwF, payloadsF] = await getNewBoundWitness([await accountC])
+      const [bwG, payloadsG] = await getNewBoundWitness([await accountD])
+      payloads.push(...payloadsA, ...payloadsB, ...payloadsC, ...payloadsD, ...payloadsE, ...payloadsF, ...payloadsG)
+      const boundWitnesses = [bwA, bwB, bwC, bwD, bwE, bwF, bwG]
+      for (const bw of boundWitnesses) {
+        await delay(2)
+        const payloadResponse = await insertBlock(archivist, bw)
+        expect(payloadResponse.length).toBe(1)
+      }
+      for (const payload of payloads) {
+        await delay(2)
+        const payloadResponse = await insertPayload(archivist, payload)
+        expect(payloadResponse.length).toBe(1)
+      }
+    })
+    describe('single address', () => {
+      it.each([
+        [accountA, () => payloads[0]],
+        [accountB, () => payloads[1]],
+      ])('returns Payload signed by address', async (account, getData) => {
+        const expected = getData()
+        const pointer = createPointer([[(await account).address]], [[expected.schema]])
+        const result = await sut.divine([pointer])
+        expect(PayloadBuilder.omitStorageMeta(result)).toEqual([expected])
+      })
+    })
+    describe('multiple address rules', () => {
+      describe('combined serially', () => {
+        it('returns Payload signed by both addresses', async () => {
+          const expected = payloads[4]
+          const pointer = createPointer([[(await accountC).address], [(await accountD).address]], [[expected.schema]])
+          const result = await sut.divine([pointer])
+          expect(PayloadBuilder.omitStorageMeta(result)).toEqual([expected])
+        })
+      })
+      describe('combined in parallel', () => {
+        it('returns Payload signed by both address', async () => {
+          const expected = payloads[4]
+          const pointer = createPointer([[(await accountC).address, (await accountD).address]], [[expected.schema]])
+          const result = await sut.divine([pointer])
+          expect(PayloadBuilder.omitStorageMeta(result)).toEqual([expected])
+        })
+      })
+    })
+    it('no matching address', async () => {
+      const pointer = createPointer([[(await Account.random()).address]], [[payloads[0].schema]])
+      const result = await sut.divine([pointer])
+      expect(result).toEqual([])
+    })
+  })
+})

package/src/spec/Diviner.payloadPointer.schema.spec.ts

@@ -0,0 +1,133 @@
+import '@xylabs/vitest-extended'
+
+import { delay } from '@xylabs/delay'
+import { Account } from '@xyo-network/account'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import {
+  beforeAll, describe, expect, it,
+} from 'vitest'
+
+import type { PayloadPointerDiviner } from '../Diviner.ts'
+import {
+  createPointer,
+  getArchivist,
+  getNewPayload,
+  getPayloadPointerDiviner,
+  getTestNode,
+  getTestSchemaName,
+  insertPayload,
+} from './testUtil/index.ts'
+
+describe('PayloadPointerDiviner', () => {
+  describe('with rules for [schema]', () => {
+    const account = Account.random()
+    const schemaA = getTestSchemaName()
+    const schemaB = getTestSchemaName()
+
+    const payloadA = {
+      ...getNewPayload(), schema: schemaA, salt: 1,
+    }
+    const payloadB = {
+      ...getNewPayload(), schema: schemaB, salt: 2,
+    }
+    const schemas = [schemaA, schemaB]
+    let node: NodeInstance
+    let archivist: ArchivistInstance
+    let sut: PayloadPointerDiviner
+    beforeAll(async () => {
+      node = await getTestNode()
+      archivist = await getArchivist(node)
+      sut = await getPayloadPointerDiviner(node)
+      const [bw] = await new BoundWitnessBuilder()
+        .payloads([payloadA, payloadB])
+        .signer(await account)
+        .build()
+      const payloads: Payload[] = [bw, payloadA, payloadB]
+      for (const payload of payloads) {
+        await delay(2)
+        const payloadResponse = await insertPayload(archivist, payload)
+        expect(payloadResponse.length).toBe(1)
+      }
+    })
+    describe('single schema', () => {
+      it.each([
+        [schemaA, payloadA],
+        [schemaB, payloadB],
+      ])('returns Payload of schema type', async (schema, expected) => {
+        const pointer = createPointer([[]], [[schema]])
+        const result = await sut.divine([pointer])
+        expect(result).toBeArrayOfSize(1)
+        const [actual] = result
+        expect(PayloadBuilder.omitMeta(actual)).toEqual(expected)
+      })
+    })
+    describe('single schema [w/address]', () => {
+      it.each([
+        [schemaA, payloadA],
+        [schemaB, payloadB],
+      ])('returns Payload of schema type', async (schema, expected) => {
+        const pointer = createPointer([[(await account).address]], [[schema]])
+        const result = await sut.divine([pointer])
+        expect(result).toBeArrayOfSize(1)
+        const [actual] = result
+        expect(PayloadBuilder.omitMeta(actual)).toEqual(expected)
+      })
+    })
+    describe('multiple schema rules', () => {
+      describe('combined serially', () => {
+        it('returns Payload of either schema', async () => {
+          const pointer = createPointer([[]], [[payloadA.schema, payloadB.schema]])
+          const results = await sut.divine([pointer])
+          expect(results).toBeDefined()
+          expect(results).toBeArrayOfSize(1)
+          const [result] = results
+          expect(result).toBeDefined()
+          expect(schemas).toContain(result.schema)
+        })
+      })
+      describe('combined serially [w/address]', () => {
+        it('returns Payload of either schema', async () => {
+          const pointer = createPointer([[(await account).address]], [[payloadA.schema, payloadB.schema]])
+          const results = await sut.divine([pointer])
+          expect(results).toBeDefined()
+          expect(results).toBeArrayOfSize(1)
+          const [result] = results
+          expect(result).toBeDefined()
+          expect(schemas).toContain(result.schema)
+        })
+      })
+      describe('combined in parallel', () => {
+        it('returns Payload of either schema', async () => {
+          const pointer = createPointer([[]], [[payloadA.schema], [payloadB.schema]])
+          const results = await sut.divine([pointer])
+          expect(results).toBeDefined()
+          expect(results).toBeArrayOfSize(1)
+          const [result] = results
+          expect(result).toBeDefined()
+          expect(schemas).toContain(result.schema)
+        })
+      })
+      describe('combined in parallel [w/address]', () => {
+        it('returns Payload of either schema', async () => {
+          const pointer = createPointer([[(await account).address]], [[payloadA.schema], [payloadB.schema]])
+          const results = await sut.divine([pointer])
+          expect(results).toBeDefined()
+          expect(results).toBeArrayOfSize(1)
+          const [result] = results
+          expect(result).toBeDefined()
+          expect(schemas).toContain(result.schema)
+        })
+      })
+    })
+    it('no matching schema', async () => {
+      const pointer = createPointer([[(await account).address]], [['network.xyo.test']])
+      const results = await sut.divine([pointer])
+      expect(results).toBeDefined()
+      expect(results).toBeEmpty()
+    })
+  })
+})

package/src/spec/Diviner.payloadPointer.sequence.spec.ts

@@ -0,0 +1,79 @@
+import '@xylabs/vitest-extended'
+
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload } from '@xyo-network/payload-model'
+import { SequenceConstants } from '@xyo-network/payload-model'
+import {
+  beforeAll,
+  describe, expect, it,
+} from 'vitest'
+
+import type { PayloadPointerDiviner } from '../Diviner.ts'
+import {
+  createPointer,
+  getArchivist,
+  getNewBoundWitness,
+  getPayloadPointerDiviner,
+  getTestNode,
+  insertBlock,
+  insertPayload,
+} from './testUtil/index.ts'
+
+describe('PayloadPointerDiviner', () => {
+  describe('with rules for [sequence]', () => {
+    let account: AccountInstance
+    let payloads: Payload[]
+    let expectedSchema: string
+    let node: NodeInstance
+    let archivist: ArchivistInstance
+    let sut: PayloadPointerDiviner
+    beforeAll(async () => {
+      node = await getTestNode()
+      archivist = await getArchivist(node)
+      sut = await getPayloadPointerDiviner(node)
+      account = await Account.random()
+      const [bwA, payloadsA] = await getNewBoundWitness([account])
+      await delay(2)
+      const [bwB, payloadsB] = await getNewBoundWitness([account])
+      await delay(2)
+      const [bwC, payloadsC] = await getNewBoundWitness([account])
+      await delay(2)
+      payloads = [...payloadsA, ...payloadsB, ...payloadsC]
+      const boundWitnesses = [bwA, bwB, bwC]
+      expectedSchema = payloadsA[0].schema
+      for (const bw of boundWitnesses) {
+        await delay(2)
+        const blockResponse = await insertBlock(archivist, bw)
+        expect(blockResponse.length).toBe(1)
+      }
+      for (const payload of payloads) {
+        await delay(2)
+        const payloadResponse = await insertPayload(archivist, payload)
+        expect(payloadResponse.length).toBe(1)
+      }
+    })
+    it('ascending', async () => {
+      const expected = assertEx(payloads.at(0))
+      const pointer = createPointer([[account.address]], [[expectedSchema]], 'asc')
+      const result = await sut.divine([pointer])
+      expect(PayloadBuilder.omitStorageMeta(result)).toEqual([expected])
+    })
+    it('descending', async () => {
+      const expected = assertEx(payloads.at(-1))
+      const pointer = createPointer([[account.address]], [[expectedSchema]], 'desc')
+      const result = await sut.divine([pointer])
+      expect(PayloadBuilder.omitStorageMeta(result)).toEqual([expected])
+    })
+    it('no matching sequence', async () => {
+      const pointer = createPointer([[account.address]], [[expectedSchema]], 'asc', SequenceConstants.maxLocalSequence)
+      const result = await sut.divine([pointer])
+      expect(result).toEqual([])
+    })
+  })
+})

package/src/spec/Diviner.spec.ts

@@ -0,0 +1,32 @@
+import '@xylabs/vitest-extended'
+
+import { PayloadPointerDivinerConfigSchema } from '@xyo-network/diviner-payload-pointer-model'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import {
+  beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { PayloadPointerDiviner } from '../Diviner.ts'
+
+describe('PayloadPointerDiviner', () => {
+  let account: WalletInstance
+  let sut: PayloadPointerDiviner
+  beforeAll(async () => {
+    account = await HDWallet.random()
+    sut = await PayloadPointerDiviner.create({
+      account,
+      config: {
+        archivist: 'archivist',
+        boundWitnessDiviner: 'boundWitnessDiviner',
+        payloadDiviner: 'payloadDiviner',
+        schema: PayloadPointerDivinerConfigSchema,
+      },
+    })
+  })
+  describe('with no input', () => {
+    it('returns empty array', async () => {
+      expect(await sut.divine()).toEqual([])
+    })
+  })
+})

package/src/spec/combineRules.spec.ts

@@ -0,0 +1,86 @@
+import '@xylabs/vitest-extended'
+
+import type {
+  PayloadAddressRule, PayloadRule, PayloadSchemaRule, PayloadSequenceOrderRule,
+} from '@xyo-network/diviner-payload-pointer-model'
+import { SequenceConstants } from '@xyo-network/payload-model'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import { combineRules } from '../combineRules.ts'
+
+const validRules = (): PayloadRule[][] => {
+  return [
+    [{ schema: 'network.xyo.debug' }],
+    [{ order: 'desc', sequence: SequenceConstants.maxLocalSequence }],
+  ]
+}
+
+describe('combineRules', () => {
+  describe('with no rules', () => {
+    it('should throw', () => {
+      expect(() => {
+        combineRules([])
+      }).toThrow()
+    })
+    it('for addresses defaults to an empty array', () => {
+      const rules = validRules()
+      const actual = combineRules(rules)
+      expect(actual.addresses.length).toBe(0)
+    })
+    it('for schema should throw', () => {
+      expect(() => {
+        const rules = validRules().filter(rule => !(rule?.[0] as PayloadSchemaRule)?.schema)
+        combineRules(rules)
+      }).toThrow()
+    })
+    describe('for sequence defaults to', () => {
+      it('sequence set to current time', () => {
+        const rules = validRules().filter(rule => !(rule?.[0] as PayloadSequenceOrderRule)?.sequence)
+        const actual = combineRules(rules)
+        expect(actual.cursor).toBe(undefined)
+      })
+      it('direction defaults to desc', () => {
+        const rules = validRules().filter(rule => !(rule?.[0] as PayloadSequenceOrderRule)?.sequence)
+        const actual = combineRules(rules)
+        expect(actual.order).toBe('desc')
+      })
+    })
+  })
+  describe('with PayloadAddressRule rules', () => {
+    it('combines multiple rules', () => {
+      const rules = validRules()
+      const addressRules: PayloadAddressRule[] = [{ address: 'foo' }, { address: 'bar' }]
+      rules.push(addressRules)
+      const actual = combineRules(rules)
+      // eslint-disable-next-line sonarjs/no-alphabetical-sort
+      expect(actual.addresses.toSorted()).toEqual(['bar', 'foo'])
+    })
+  })
+  describe('with PayloadSchemaRule rules', () => {
+    it('combines multiple rules', () => {
+      const rules: PayloadRule[][] = [
+        [{ order: 'desc', sequence: SequenceConstants.maxLocalSequence }],
+        [{ schema: 'network.xyo.test' }, { schema: 'network.xyo.debug' }],
+      ]
+      const actual = combineRules(rules)
+      // eslint-disable-next-line sonarjs/no-alphabetical-sort
+      expect(actual.schemas.toSorted()).toEqual(['network.xyo.debug', 'network.xyo.test'])
+    })
+  })
+  describe('with multiple PayloadSequenceDirectionRule rules', () => {
+    it('should only allow one rule', () => {
+      const rules: PayloadRule[][] = [
+        [{ schema: 'network.xyo.debug' }],
+        [
+          { order: 'desc', sequence: SequenceConstants.maxLocalSequence },
+          { order: 'asc', sequence: SequenceConstants.minLocalSequence },
+        ],
+      ]
+      expect(() => {
+        combineRules(rules)
+      }).toThrow()
+    })
+  })
+})

package/xy.config.ts

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