@xyo-network/xl1-protocol-sdk 1.7.8 → 1.7.9

package/src/block/primitives/frames/spec/calculateFramesFromRange.spec.ts

@@ -0,0 +1,70 @@
+import { stepSize } from '@xyo-network/xl1-protocol'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import { calculateFramesFromRange } from '../calculateFramesFromRange.ts'
+
+describe('calculateFramesFromRange', () => {
+  it('handles range aligned with step size', () => {
+    const step = 1 // 105
+    const range: [number, number] = [0, stepSize(step) - 1]
+    const [fitted, remaining] = calculateFramesFromRange(range, step)
+
+    expect(fitted).toEqual([[0, 30]])
+    expect(remaining).toEqual([])
+  })
+
+  it('handles range starting at step boundary but incomplete', () => {
+    const step = 1
+    const range: [number, number] = [stepSize(step), stepSize(step) + 1]
+    const [fitted, remaining] = calculateFramesFromRange(range, step)
+
+    expect(fitted).toEqual([])
+    expect(remaining).toEqual([range])
+  })
+
+  it('handles range starting at step boundary (step 1)', () => {
+    const step = 1
+    const multiplier = 2
+    const additional = 1
+    const range: [number, number] = [stepSize(step), (stepSize(step) + additional) * multiplier]
+    const [fitted, remaining] = calculateFramesFromRange(range, step)
+
+    expect(fitted).toEqual([[31, 61]])
+    expect(remaining).toEqual([[62, 64]])
+  })
+
+  it('handles range starting at step boundary (step 5)', () => {
+    const step = 5
+    const multiplier = 2
+    const additional = 17
+    const range: [number, number] = [stepSize(step), (stepSize(step) + additional) * multiplier]
+    const [fitted, remaining] = calculateFramesFromRange(range, step)
+
+    expect(fitted).toEqual([[510_511, 1_021_021]])
+    expect(remaining).toEqual([[1_021_022, 1_021_056]])
+  })
+
+  it('handles range starting not at step boundary', () => {
+    const step = 1
+    const multiplier = 2
+    const additional = 1
+    const range: [number, number] = [stepSize(step) - additional, (stepSize(step) + additional) * multiplier]
+    const [fitted, remaining] = calculateFramesFromRange(range, step)
+
+    expect(fitted).toEqual([[31, 61]])
+    expect(remaining).toEqual([[range[0], 30], [62, range[1]]])
+  })
+
+  it('handles range starting not at step boundary (step 5)', () => {
+    const step = 5
+    const multiplier = 2
+    const additional = 17
+    const range: [number, number] = [stepSize(step) - additional, (stepSize(step) + additional) * multiplier]
+    const [fitted, remaining] = calculateFramesFromRange(range, step)
+
+    expect(fitted).toEqual([[510_511, 1_021_021]])
+    expect(remaining).toEqual([[range[0], 510_510], [1_021_022, range[1]]])
+  })
+})

package/src/block/primitives/frames/spec/deepCalculateFramesFromRange.spec.ts

@@ -0,0 +1,75 @@
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import type { BlockNumberRange } from '../BlockNumberRange.ts'
+import { deepCalculateFramesFromRange } from '../deepCalculateFramesFromRange.ts'
+
+describe('deepCalculateFramesFromRange', () => {
+  it('calculates frames for a simple range with one step level', () => {
+    const range: BlockNumberRange = [0, 9]
+    const result = deepCalculateFramesFromRange(range)
+
+    // With step 0 (size 10), this should fit in one frame
+    expect(result).toEqual([[0, 6], [7, 7], [8, 8], [9, 9]])
+  })
+
+  it('calculates frames for a range spanning multiple step sizes', () => {
+    const range: BlockNumberRange = [0, 250]
+    const result = deepCalculateFramesFromRange(range)
+
+    expect(result).toContainEqual([0, 210])
+
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(11)
+  })
+
+  it('calculates frames for range with multiple step levels - [0, 1500]', () => {
+    const range: BlockNumberRange = [0, 1500]
+    const result = deepCalculateFramesFromRange(range)
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(19)
+  })
+
+  it('calculates frames for range with multiple step levels - [0, 3000]', () => {
+    const range: BlockNumberRange = [0, 3000]
+    const result = deepCalculateFramesFromRange(range)
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(31)
+  })
+
+  it('calculates frames for range with multiple step levels = [45, 1599]', () => {
+    const range: BlockNumberRange = [45, 1599]
+    const result = deepCalculateFramesFromRange(range)
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(43)
+  })
+
+  it('calculates frames for range with multiple step levels = [45, 3333]', () => {
+    const range: BlockNumberRange = [45, 3333]
+    const result = deepCalculateFramesFromRange(range)
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(85)
+  })
+
+  it('calculates frames for range with multiple step levels - [23_145, 230_102_040]', () => {
+    const range: BlockNumberRange = [23_145, 230_102_040]
+    const result = deepCalculateFramesFromRange(range)
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(742)
+  })
+
+  it('calculates frames for range with multiple step levels - [23_145, 34_548_554_394]', () => {
+    const range: BlockNumberRange = [23_145, 34_548_554_394]
+    const result = deepCalculateFramesFromRange(range)
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(1468)
+  })
+
+  it('calculates frames for range with multiple step levels - [23_145, 4_598_734_539_845]', () => {
+    const range: BlockNumberRange = [23_145, 4_598_734_539_845]
+    const result = deepCalculateFramesFromRange(range)
+    expect(result).toMatchSnapshot(result)
+    expect(result.length).toEqual(2445)
+  })
+})

package/src/config/index.ts

@@ -1 +1,2 @@
 export * from './Config.ts'
+export { hasMongoConfig } from './storage/index.ts'

package/src/config/storage/driver/Mongo.ts

@@ -1,12 +1,31 @@
+import { isDefined, isUndefined } from '@xylabs/typeof'
 import z from 'zod'
 
+/**
+ * Checks if the provided MongoDB configuration contains all necessary fields
+ * for establishing a connection.
+ * @param config MongoDB configuration object
+ * @returns True if the configuration contains all necessary fields for
+ * establishing a connection
+ */
+export const hasMongoConfig = (config?: MongoConfig): config is Required<MongoConfig> => {
+  if (isUndefined(config)) return false
+  return (
+    isDefined(config.connectionString)
+    && isDefined(config.database)
+    && isDefined(config.domain)
+    && isDefined(config.password)
+    && isDefined(config.username)
+  )
+}
+
 export const MongoConfigSchema = z.object({
   // TODO: Create from other arguments
-  connectionString: z.string().min(1).max(1024).optional().describe('MongoDB connection string'),
-  database: z.string().min(1).max(128).optional().describe('MongoDB database name'),
-  domain: z.string().min(1).max(128).optional().describe('MongoDB domain'),
-  password: z.string().min(1).max(128).optional().describe('MongoDB password'),
-  username: z.string().min(1).max(128).optional().describe('MongoDB username'),
+  connectionString: z.string().min(1).optional().describe('MongoDB connection string'),
+  database: z.string().min(1).optional().describe('MongoDB database name'),
+  domain: z.string().min(1).optional().describe('MongoDB domain'),
+  password: z.string().min(1).optional().describe('MongoDB password'),
+  username: z.string().min(1).optional().describe('MongoDB username'),
 })
 
 export type MongoConfig = z.infer<typeof MongoConfigSchema>

package/src/config/storage/index.ts

@@ -1 +1,2 @@
+export * from './driver/index.ts'
 export * from './Storage.ts'

package/src/transaction/primitives/spec/transactionBlockByteCount.spec.ts

@@ -0,0 +1,242 @@
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { AnyPayload } from '@xyo-network/payload-model'
+import type { HydratedTransaction, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import { transactionBlockByteCount } from '../transactionBlockByteCount.ts'
+
+const hydratedTransaction: HydratedTransaction<TransactionBoundWitness, AnyPayload> = [
+  {
+    schema: 'network.xyo.boundwitness',
+    addresses: [
+      '136c12e131f5e3eef708dbde954a2841dd72f9af',
+    ],
+    payload_hashes: [
+      '6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d',
+      '1f9b639358aefa6f3c2467a7d571cde3b68b8fd5d9c7af6a14d0a4023832286f',
+    ],
+    payload_schemas: [
+      'network.xyo.hash',
+      'network.xyo.crypto.asset',
+    ],
+    previous_hashes: [
+      null,
+    ],
+    $signatures: [
+      'c6c4101d2854046974cebd14a941e61ff969f7cf523f677bec2907d262ad98235e00bf829be6344241b5f25cb313c3cadeb0b0abda618b8cfee359859d4246f4',
+    ],
+    nbf: 25_383,
+    exp: 26_383,
+    fees: {
+      base: '038d7ea4c68000',
+      gasLimit: '0de0b6b3a7640000',
+      gasPrice: '09184e72a000',
+      priority: '00',
+    },
+    chain: 'a82920051db4fcbb804463440dd45e03f72442fd',
+    from: '136c12e131f5e3eef708dbde954a2841dd72f9af',
+    script: [
+      'elevate|6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d',
+    ],
+    _dataHash: '9c6c0ebf16761fc219d8235b398fa058db05f3b139a821f812683c5434e4d08b',
+    _hash: 'bd5909fa90603cba7c794ce8358140467a2aeee1845feaabcac3ad1d3e0dd48a',
+    _sequence: '0000000000000000000000003e0dd48a',
+  },
+  [
+    {
+      schema: 'network.xyo.hash',
+      hash: '1f9b639358aefa6f3c2467a7d571cde3b68b8fd5d9c7af6a14d0a4023832286f',
+      _dataHash: '6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d',
+      _hash: '6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d',
+      _sequence: '000001975b401332000000030658873d',
+    },
+  ],
+]
+
+describe('transactionBlockByteCount', () => {
+  it('calculates correct byte count for a transaction with no payloads', () => {
+    // Expected byte count - transaction only (no payloads)
+    const expectedCleanTransaction = PayloadBuilder.omitStorageMeta(hydratedTransaction[0])
+    const expectedCleanPayloads = PayloadBuilder.omitStorageMeta(hydratedTransaction[1])
+    const expectedByteCount = JSON.stringify(expectedCleanTransaction).length
+      + expectedCleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0)
+
+    // Act
+    const actualByteCount = transactionBlockByteCount(hydratedTransaction)
+
+    // Assert
+    expect(actualByteCount).toBe(expectedByteCount)
+  })
+
+  it('calculates correct byte count for a transaction with multiple payloads', () => {
+    // Expected byte count - transaction + payloads (without $meta)
+    const expectedCleanTransaction = PayloadBuilder.omitStorageMeta(hydratedTransaction[0])
+    const expectedCleanPayloads = PayloadBuilder.omitStorageMeta(hydratedTransaction[1])
+    const expectedByteCount
+      = JSON.stringify(expectedCleanTransaction).length
+        + expectedCleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0)
+
+    // Act
+    const actualByteCount = transactionBlockByteCount(hydratedTransaction)
+
+    // Assert
+    expect(actualByteCount).toBe(expectedByteCount)
+  })
+
+  it('handles transaction with empty payload array', () => {
+    // Arrange
+    const emptyPayloadsTransaction: HydratedTransaction = [
+      { ...hydratedTransaction[0] },
+      [], // Empty payload array
+    ]
+
+    // Expected byte count - transaction only with no payloads
+    const expectedCleanTransaction = PayloadBuilder.omitStorageMeta(emptyPayloadsTransaction[0])
+    const expectedByteCount = JSON.stringify(expectedCleanTransaction).length
+
+    // Act
+    const actualByteCount = transactionBlockByteCount(emptyPayloadsTransaction)
+
+    // Assert
+    expect(actualByteCount).toBe(expectedByteCount)
+  })
+
+  it('correctly handles payloads with complex nested structures', async () => {
+    // Arrange
+    const complexPayload = await PayloadBuilder.addStorageMeta({
+      schema: 'network.xyo.complex',
+      data: {
+        nested: {
+          array: [1, 2, 3, 4, 5],
+          objects: [
+            { id: 1, name: 'item1' },
+            { id: 2, name: 'item2' },
+          ],
+          deepNesting: { level1: { level2: { level3: 'deep value' } } },
+        },
+      },
+    })
+
+    const complexTransaction: HydratedTransaction = [
+      { ...hydratedTransaction[0] },
+      [complexPayload],
+    ]
+
+    // Expected byte count
+    const expectedCleanTransaction = PayloadBuilder.omitStorageMeta(complexTransaction[0])
+    const expectedCleanPayloads = PayloadBuilder.omitStorageMeta([complexPayload])
+    const expectedByteCount
+      = JSON.stringify(expectedCleanTransaction).length
+        + JSON.stringify(expectedCleanPayloads[0]).length
+
+    // Act
+    const actualByteCount = transactionBlockByteCount(complexTransaction)
+
+    // Assert
+    expect(actualByteCount).toBe(expectedByteCount)
+  })
+
+  it('returns correct byte count for transaction with multiple large payloads', async () => {
+    // Arrange
+    const largePayloads = await PayloadBuilder.addStorageMeta(Array.from({ length: 5 }, (_, i) => ({
+      schema: `network.xyo.test.${i}`,
+      data: Array.from({ length: 100 }, (_, j) => `data-item-${j}`),
+      metadata: {
+        timestamp: Date.now(),
+        source: `test-source-${i}`,
+        tags: Array.from({ length: 10 }, (_, k) => `tag-${k}`),
+      },
+      _dataHash: `datahash${i}`,
+      _hash: `hash${i}`,
+    })))
+
+    const largeTransaction: HydratedTransaction = [
+      { ...hydratedTransaction[0] },
+      largePayloads,
+    ]
+
+    // Expected byte count
+    const expectedCleanTransaction = PayloadBuilder.omitStorageMeta(largeTransaction[0])
+    const expectedCleanPayloads = PayloadBuilder.omitStorageMeta(largePayloads)
+
+    let expectedByteCount = JSON.stringify(expectedCleanTransaction).length
+    for (const payload of expectedCleanPayloads) {
+      expectedByteCount += JSON.stringify(payload).length
+    }
+
+    // Act
+    const actualByteCount = transactionBlockByteCount(largeTransaction)
+
+    // Assert
+    expect(actualByteCount).toBe(expectedByteCount)
+  })
+
+  it('handles transactions with special characters in payloads', async () => {
+    // Arrange
+    const specialCharPayload = await PayloadBuilder.addStorageMeta({
+      schema: 'network.xyo.special',
+      text: 'Special characters: 你好, ñáéíóú, 🚀 💻 🔗, \u0000\u0001\u0002',
+      escapes: '\\n\\t\\r\\"\\\'\\\\',
+      _hash: 'special-hash',
+    })
+
+    const specialTransaction: HydratedTransaction = [
+      { ...hydratedTransaction[0] },
+      [specialCharPayload],
+    ]
+
+    // Expected byte count
+    const expectedCleanTransaction = PayloadBuilder.omitStorageMeta(specialTransaction[0])
+    const expectedCleanPayload = PayloadBuilder.omitStorageMeta([specialCharPayload])
+    const expectedByteCount
+      = JSON.stringify(expectedCleanTransaction).length
+        + JSON.stringify(expectedCleanPayload[0]).length
+
+    // Act
+    const actualByteCount = transactionBlockByteCount(specialTransaction)
+
+    // Assert
+    expect(actualByteCount).toBe(expectedByteCount)
+  })
+
+  it('correctly omits all storage metadata fields from byte count', async () => {
+    // Arrange
+    const txWithExtraMeta = await PayloadBuilder.addStorageMeta({
+      ...hydratedTransaction[0],
+      _extraMeta1: 'should be omitted',
+      _extraMeta2: 'should be omitted as well',
+    })
+
+    const payloadWithExtraMeta = await PayloadBuilder.addStorageMeta({
+      schema: 'network.xyo.test',
+      data: 'test data',
+      _extraMeta1: 'should be omitted',
+      _extraMeta2: 'should be omitted as well',
+    })
+
+    const transactionWithExtraMeta: HydratedTransaction = [
+      txWithExtraMeta,
+      [payloadWithExtraMeta],
+    ]
+
+    // Expected byte count - all meta fields should be omitted
+    const expectedCleanTransaction = PayloadBuilder.omitStorageMeta(txWithExtraMeta)
+    const expectedCleanPayload = PayloadBuilder.omitStorageMeta([payloadWithExtraMeta])
+    const expectedByteCount
+      = JSON.stringify(expectedCleanTransaction).length
+        + JSON.stringify(expectedCleanPayload[0]).length
+
+    // Act
+    const actualByteCount = transactionBlockByteCount(transactionWithExtraMeta)
+
+    // Assert
+    expect(actualByteCount).toBe(expectedByteCount)
+    // Verify meta fields are actually omitted
+    expect(expectedCleanTransaction).not.toHaveProperty('$meta')
+    expect(expectedCleanTransaction).not.toHaveProperty('_extraMeta1')
+    expect(expectedCleanPayload[0]).not.toHaveProperty('$meta')
+    expect(expectedCleanPayload[0]).not.toHaveProperty('_extraMeta1')
+  })
+})

package/src/validation/lib/spec/isLocalhost.spec.ts

@@ -0,0 +1,20 @@
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import { isLocalhost } from '../isLocalhost.ts'
+
+describe('is.ts type guards', () => {
+  describe('isLocalhost', () => {
+    it('correctly identifies localhost strings', () => {
+      expect(isLocalhost('localhost')).toBe(true)
+      expect(isLocalhost('127.0.0.1')).toBe(true)
+      expect(isLocalhost('::1')).toBe(true)
+      expect(isLocalhost('example.localhost')).toBe(true)
+
+      expect(isLocalhost('example.com')).toBe(false)
+      expect(isLocalhost('')).toBe(false)
+      expect(isLocalhost('local')).toBe(false)
+    })
+  })
+})

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