@xyo-network/xl1-protocol-sdk 1.16.16 → 1.16.17

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

@@ -1,72 +0,0 @@
-import {
-  asXL1BlockRange, stepSize, XL1_BLOCK_NUMBER_ZERO,
-} 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 // 31
-    const range = asXL1BlockRange([XL1_BLOCK_NUMBER_ZERO, stepSize(step) - 1], true)
-    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 = asXL1BlockRange([stepSize(step), stepSize(step) + 1], true)
-    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 = asXL1BlockRange([stepSize(step), (stepSize(step) + additional) * multiplier], true)
-    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 = asXL1BlockRange([stepSize(step), (stepSize(step) + additional) * multiplier], true)
-    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 = asXL1BlockRange([stepSize(step) - additional, (stepSize(step) + additional) * multiplier], true)
-    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 = asXL1BlockRange([stepSize(step) - additional, (stepSize(step) + additional) * multiplier], true)
-    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

@@ -1,75 +0,0 @@
-import { asXL1BlockRange } from '@xyo-network/xl1-protocol'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { deepCalculateFramesFromRange } from '../deepCalculateFramesFromRange.ts'
-
-describe('deepCalculateFramesFromRange', () => {
-  it('calculates frames for a simple range with one step level', () => {
-    const range = asXL1BlockRange([0, 9], true)
-    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 = asXL1BlockRange([0, 250], true)
-    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 = asXL1BlockRange([0, 1500], true)
-    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 = asXL1BlockRange([0, 3000], true)
-    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 = asXL1BlockRange([45, 1599], true)
-    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 = asXL1BlockRange([45, 3333], true)
-    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 = asXL1BlockRange([23_145, 230_102_040], true)
-    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 = asXL1BlockRange([23_145, 34_548_554_394], true)
-    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 = asXL1BlockRange([23_145, 4_598_734_539_845], true)
-    const result = deepCalculateFramesFromRange(range)
-    expect(result).toMatchSnapshot(result)
-    expect(result.length).toEqual(2445)
-  })
-})

package/src/eip-712/spec/signAndVerify.spec.ts

@@ -1,27 +0,0 @@
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { EIP712SignaturePayloadSchema } from '../Payloads/index.ts'
-import { signEIP712Message } from '../sign.ts'
-import { verifyEIP712Message } from '../verify.ts'
-import { samplePayload, wallet } from './fixtures.ts'
-
-describe('signEIP712Message', () => {
-  it('should sign an EIP-712 message and return the correct payload', async () => {
-    const payload = await signEIP712Message(wallet, samplePayload)
-
-    expect(payload.address).toEqual(await wallet.getAddress())
-    expect(payload.signature).toBeDefined()
-    expect(payload.schema).toEqual(EIP712SignaturePayloadSchema)
-    expect(payload.hash).toBeDefined()
-  })
-
-  it('should verify the signature of an EIP-712 message', async () => {
-    const payload = await signEIP712Message(wallet, samplePayload)
-
-    const isValidSignature = await verifyEIP712Message(samplePayload, payload)
-
-    expect(isValidSignature).toBe(true)
-  })
-})

package/src/primitives/step/spec/completedStepRewardAddress.spec.ts

@@ -1,28 +0,0 @@
-import { asXL1BlockNumber } from '@xyo-network/xl1-protocol'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { completedStepRewardAddress } from '../completedStepRewardAddress.ts'
-
-describe('completedStepRewardAddress', () => {
-  it('should get index [single entry - step size]', () => {
-    const address = completedStepRewardAddress({ block: asXL1BlockNumber(2311, true), step: 2311 })
-    expect (address).toBe('93d321ab2e01ce14bbe601d3c49b330d250c5ab1')
-  })
-
-  it('should get index [single entry - step ordinal]', () => {
-    const address = completedStepRewardAddress({ block: asXL1BlockNumber(2311, true), step: 3 })
-    expect (address).toBe('93d321ab2e01ce14bbe601d3c49b330d250c5ab1')
-  })
-
-  it('should get index [single entry - step size]', () => {
-    const address = completedStepRewardAddress({ block: asXL1BlockNumber(2311 * 2, true), step: 2311 })
-    expect (address).toBe('04c602f975a00794efd01e5fe07266cc1945f321')
-  })
-
-  it('should get index [single entry - step ordinal]', () => {
-    const address = completedStepRewardAddress({ block: asXL1BlockNumber(2311 * 2, true), step: 3 })
-    expect (address).toBe('04c602f975a00794efd01e5fe07266cc1945f321')
-  })
-})

package/src/primitives/step/spec/stepTransferIndex.spec.ts

@@ -1,23 +0,0 @@
-import { StepSizes } from '@xyo-network/xl1-protocol'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { stepTransferIndex } from '../stepTransferIndex.ts'
-
-describe('getStepTransferIndex', () => {
-  it('should get index [single entry]', { timeout: 120_000 }, () => {
-    const index = stepTransferIndex(StepSizes[3], 3)
-    expect (index[0]).toBe(0)
-    expect (index[1]).toBe(1)
-  })
-  it('should get index [double entry]', { timeout: 120_000 }, () => {
-    const index3 = stepTransferIndex(StepSizes[3] * StepSizes[4], 3)
-    expect (index3[0]).toBe(0)
-    expect (index3[1]).toBe(2)
-
-    const index4 = stepTransferIndex(StepSizes[3] * StepSizes[4], 4)
-    expect (index4[0]).toBe(1)
-    expect (index4[1]).toBe(2)
-  })
-})

package/src/simple/network/spec/XyoNetwork.spec.ts

@@ -1,77 +0,0 @@
-import type { NetworkId } from '@xyo-network/xl1-protocol'
-import { NetworkStatusSchema } from '@xyo-network/xl1-protocol'
-import axios from 'axios'
-import type { Mocked } from 'vitest'
-import {
-  beforeEach, describe, expect, it, vitest,
-} from 'vitest'
-
-import {
-  errorStatus, StatusNetworks, unknownStatus,
-} from '../lib/index.ts'
-import { SimpleXyoNetwork } from '../SimpleXyoNetwork.ts'
-
-vitest.mock('axios')
-const mockedAxios = axios as Mocked<typeof axios>
-
-describe('SimpleXyoNetwork', () => {
-  const mockNetworkStatus = {
-    description: 'Mock Network Status',
-    schema: NetworkStatusSchema,
-    state: 'active',
-  }
-
-  const networks = Object.values(StatusNetworks)
-
-  beforeEach(() => {
-    vitest.clearAllMocks()
-  })
-
-  for (const { id, statusUrl } of networks) {
-    it(`should fetch the ${id} status successfully`, async () => {
-      mockedAxios.get.mockResolvedValueOnce({ data: mockNetworkStatus })
-
-      const network = new SimpleXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(mockNetworkStatus)
-    })
-
-    it(`should return unknownStatus for invalid response data on ${id}`, async () => {
-      mockedAxios.get.mockResolvedValueOnce({ data: { invalid: 'data' }, status: 200 })
-
-      const network = new SimpleXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(unknownStatus)
-    })
-
-    it(`should return errorStatus for non-200 response on ${id}`, async () => {
-      mockedAxios.get.mockResolvedValueOnce({ data: {}, status: 500 })
-
-      const network = new SimpleXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(errorStatus)
-    })
-
-    it(`should return errorStatus for network errors on ${id}`, async () => {
-      mockedAxios.get.mockRejectedValueOnce(new Error('Network error'))
-
-      const network = new SimpleXyoNetwork(id)
-      const status = await network.status()
-
-      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
-      expect(status).toEqual(errorStatus)
-    })
-  }
-
-  it('should throw an error for unknown network ID', async () => {
-    const network = new SimpleXyoNetwork('invalid' as unknown as NetworkId)
-
-    await expect(network.status()).rejects.toThrow('Unknown status network ID: invalid')
-  })
-})

package/src/simple/permissions/spec/SimpleXyoPermissions.spec.ts

@@ -1,93 +0,0 @@
-import {
-  beforeEach, describe, expect, it,
-} from 'vitest'
-
-import type { PermissionRequest } from '../../../provider/index.ts'
-import { SimpleXyoPermissions } from '../SimpleXyoPermissions.ts'
-import { MemoryPermissionsStore } from '../store/index.ts'
-
-describe('MemoryXyoPermissions', () => {
-  const invoker = 'https://example.com'
-  const parentCapability = 'xyoViewer_chainId'
-  let memoryPermissions: SimpleXyoPermissions
-
-  // Helper to build PermissionRequest
-  const buildPermissionRequest = (cap: string, caveats: Record<string, unknown> = {}) =>
-    ({ [cap]: caveats }) as PermissionRequest
-
-  beforeEach(() => {
-    memoryPermissions = new SimpleXyoPermissions(new MemoryPermissionsStore(invoker))
-  })
-
-  it('returns an empty list initially', async () => {
-    const permissions = await memoryPermissions.getPermissions()
-    expect(permissions).toEqual([])
-  })
-
-  it('adds and retrieves a permission', async () => {
-    const req = buildPermissionRequest(parentCapability)
-    const result = await memoryPermissions.requestPermissions([req])
-    expect(Array.isArray(result)).toBe(true)
-    expect(result.length).toBe(1)
-    expect(result[0].parentCapability).toBe(parentCapability)
-    expect(typeof result[0].date).toBe('number')
-
-    const permissions = await memoryPermissions.getPermissions()
-    expect(permissions.length).toBe(1)
-    expect(permissions[0].parentCapability).toBe(parentCapability)
-    expect(permissions[0].invoker).toBe(invoker)
-    expect(typeof permissions[0].date).toBe('number')
-  })
-
-  it('replaces an existing permission with the same key', async () => {
-    const req = buildPermissionRequest(parentCapability)
-    await memoryPermissions.requestPermissions([req])
-    const originalDate = (await memoryPermissions.getPermissions())[0].date
-
-    await new Promise(r => setTimeout(r, 5)) // ensure timestamp difference
-    await memoryPermissions.requestPermissions([req])
-    const updatedDate = (await memoryPermissions.getPermissions())[0].date
-
-    expect(updatedDate).toBeGreaterThan(originalDate!)
-  })
-
-  it('revokes a previously granted permission', async () => {
-    const req = buildPermissionRequest(parentCapability)
-    await memoryPermissions.requestPermissions([req])
-    expect((await memoryPermissions.getPermissions()).length).toBe(1)
-
-    const result = await memoryPermissions.revokePermissions(req)
-    expect(Array.isArray(result)).toBe(true)
-    expect(result.length).toBe(1)
-    expect(result[0].parentCapability).toBe(parentCapability)
-
-    const permissions = await memoryPermissions.getPermissions()
-    expect(permissions).toEqual([])
-  })
-
-  it('revoking a non-existent permission does nothing and returns empty array', async () => {
-    const req = buildPermissionRequest(parentCapability)
-    const result = await memoryPermissions.revokePermissions(req)
-    expect(result).toEqual([])
-    expect(await memoryPermissions.getPermissions()).toEqual([])
-  })
-
-  it('can handle multiple permissions from different invokers', async () => {
-    const memoryPermissionsA = new SimpleXyoPermissions(new MemoryPermissionsStore('https://a.com'))
-    const memoryPermissionsB = new SimpleXyoPermissions(new MemoryPermissionsStore('https://b.com'))
-    const reqA1 = buildPermissionRequest('xyo_1')
-    const reqA2 = buildPermissionRequest('xyo_3')
-    const reqB = buildPermissionRequest('xyo_2')
-
-    await memoryPermissionsA.requestPermissions([reqA1, reqA2])
-    await memoryPermissionsB.requestPermissions([reqB])
-
-    const resultsA = await memoryPermissionsA.getPermissions()
-    const resultsB = await memoryPermissionsB.getPermissions()
-
-    expect(resultsA.length).toBe(2)
-    expect(resultsB.length).toBe(1)
-    expect(resultsA.map(p => p.parentCapability).toSorted((a, b) => a.localeCompare(b))).toEqual(['xyo_1', 'xyo_3'])
-    expect(resultsB[0].parentCapability).toBe('xyo_2')
-  })
-})

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

@@ -1,245 +0,0 @@
-import type {
-  Address, Hash, Hex,
-} from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { AnyPayload, Sequence } from '@xyo-network/payload-model'
-import type { SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { transactionBlockByteCount } from '../transactionBlockByteCount.ts'
-
-const hydratedTransaction: SignedHydratedTransactionWithStorageMeta<TransactionBoundWitness, AnyPayload> = [
-  {
-    schema: 'network.xyo.boundwitness',
-    addresses: [
-      '136c12e131f5e3eef708dbde954a2841dd72f9af' as Address,
-    ],
-    payload_hashes: [
-      '6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d' as Hash,
-      '1f9b639358aefa6f3c2467a7d571cde3b68b8fd5d9c7af6a14d0a4023832286f' as Hash,
-    ],
-    payload_schemas: [
-      'network.xyo.hash',
-      'network.xyo.crypto.asset',
-    ],
-    previous_hashes: [
-      null,
-    ],
-    $signatures: [
-      'c6c4101d2854046974cebd14a941e61ff969f7cf523f677bec2907d262ad98235e00bf829be6344241b5f25cb313c3cadeb0b0abda618b8cfee359859d4246f4' as Hex,
-    ],
-    nbf: 25_383,
-    exp: 26_383,
-    fees: {
-      base: '038d7ea4c68000' as Hex,
-      gasLimit: '0de0b6b3a7640000' as Hex,
-      gasPrice: '09184e72a000' as Hex,
-      priority: '00' as Hex,
-    },
-    chain: 'a82920051db4fcbb804463440dd45e03f72442fd' as Address,
-    from: '136c12e131f5e3eef708dbde954a2841dd72f9af' as Address,
-    script: [
-      'elevate|6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d',
-    ],
-    _dataHash: '9c6c0ebf16761fc219d8235b398fa058db05f3b139a821f812683c5434e4d08b' as Hash,
-    _hash: 'bd5909fa90603cba7c794ce8358140467a2aeee1845feaabcac3ad1d3e0dd48a' as Hash,
-    _sequence: '0000000000000000000000003e0dd48a' as Sequence,
-  },
-  [
-    {
-      schema: 'network.xyo.hash',
-      hash: '1f9b639358aefa6f3c2467a7d571cde3b68b8fd5d9c7af6a14d0a4023832286f',
-      _dataHash: '6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d' as Hash,
-      _hash: '6d12a4aae2d7056b5b9b1a5e078c883e7ebf887a86d16a4e5e87b5940658873d' as Hash,
-      _sequence: '000001975b401332000000030658873d' as Sequence,
-    },
-  ],
-]
-
-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: SignedHydratedTransactionWithStorageMeta = [
-      { ...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: SignedHydratedTransactionWithStorageMeta = [
-      { ...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: SignedHydratedTransactionWithStorageMeta = [
-      { ...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: SignedHydratedTransactionWithStorageMeta = [
-      { ...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: SignedHydratedTransactionWithStorageMeta = [
-      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')
-  })
-})