@xyo-network/payload-utils 5.3.22 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/payload-utils",
-  "version": "5.3.22",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,40 +30,36 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*",
     "README.md"
   ],
   "dependencies": {
-    "@xyo-network/boundwitness-model": "~5.3.22",
-    "@xyo-network/hash": "~5.3.22",
-    "@xyo-network/payload-builder": "~5.3.22",
-    "@xyo-network/payload-model": "~5.3.22"
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/hash": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.8",
-    "@xylabs/ts-scripts-yarn3": "~7.6.8",
-    "@xylabs/tsconfig": "~7.6.8",
-    "@xylabs/vitest-extended": "~5.0.91",
-    "@xyo-network/boundwitness-model": "~5.3.22",
-    "@xyo-network/hash": "~5.3.22",
-    "@xyo-network/payload-builder": "~5.3.22",
-    "@xyo-network/payload-model": "~5.3.22",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
     "acorn": "^8.16.0",
     "axios": "^1.14.0",
-    "cosmiconfig": "^9.0.1",
-    "esbuild": "^0.27.4",
-    "eslint": "^10.1.0",
-    "rollup": "^4.60.1",
+    "esbuild": "^0.28.0",
     "typescript": "~5.9.3",
     "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/hash": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
@@ -72,4 +68,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/combinationsByBoundwitness.ts

@@ -1,29 +0,0 @@
-import {
-  asHash, difference, exists,
-} from '@xylabs/sdk-js'
-import type { BoundWitness } from '@xyo-network/boundwitness-model'
-import { isBoundWitness } from '@xyo-network/boundwitness-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-
-/**
- * Returns tuples of bound witnesses and their payloads from the supplied payloads. Omits
- * bound witnesses where the payloads were not included in the supplied payloads.
- * @param payloads An array of bound witnesses and payloads
- * @returns An array of tuples of bound witnesses and their payloads
- */
-export const combinationsByBoundwitness = async (payloads: Payload[]): Promise<[BoundWitness, ...Payload[]][]> => {
-  const bws = new Set<BoundWitness>(payloads.filter(x => isBoundWitness(x)))
-  const remaining = difference(new Set(payloads), bws)
-  const payloadDictionary = await PayloadBuilder.toHashMap([...remaining])
-  const results = [] as [BoundWitness, ...Payload[]][]
-  for (const bw of bws) {
-    const { payload_hashes } = bw
-    const p = payload_hashes.map(h => payloadDictionary[asHash(h, true)]).filter(exists)
-    if (p.length === payload_hashes.length) {
-      const complete = [bw, ...p] as [BoundWitness, ...Payload[]]
-      results.push(complete)
-    }
-  }
-  return results
-}

package/src/combinationsBySchema.ts

@@ -1,67 +0,0 @@
-import { ObjectHasher } from '@xyo-network/hash'
-import type { Payload } from '@xyo-network/payload-model'
-
-/**
- * Generates a unique key for a tuple of payloads
- * @param payloads An array of payloads
- * @returns A string that is a unique key for the payloads
- */
-const generateKeyForTuple = async (payloads: Payload[]): Promise<string> => {
-  // return (await Promise.all(array.map((p) => PayloadBuilder.dataHash(p)))).join('|')
-  await Promise.resolve() // Here to reserve the right to make this async
-  return payloads.map(p => ObjectHasher.stringifyHashFields(p)).join('|')
-}
-
-/**
- * Returns the unique combinations of payloads for the given schemas
- * @param payloads An array of payloads
- * @param schemas An array of schemas
- * @returns An array of unique combinations of payloads
- */
-export const combinationsBySchema = async (payloads: Payload[], schemas: string[]): Promise<Payload[][]> => {
-  // Group payloads by schema
-  const groupedPayloads: Record<string, Payload[]> = Object.fromEntries(schemas.map(schema => [schema, []]))
-  for (const payload of payloads) {
-    if (schemas.includes(payload.schema)) {
-      groupedPayloads[payload.schema].push(payload)
-    }
-  }
-
-  // Set to track seen (serialized) combinations for uniqueness check
-  const seen: Set<string> = new Set()
-  // Start with an array containing an empty combination
-  let combinations = [[]] as Payload[][]
-
-  // Iterate over each schema
-  for (const schema of schemas) {
-    const newCombinations: Payload[][] = []
-    // Iterate over existing combinations
-    for (const combination of combinations) {
-      // Iterate over payloads for the current schema
-      for (const payload of groupedPayloads[schema]) {
-        // Create a new combination by adding the current payload
-        const newPerm = [...combination, payload]
-        // Proceed with serialization only if the combination is complete
-        if (newPerm.length === schemas.length) {
-          // Serialize the new combination asynchronously
-          const serialized = await generateKeyForTuple(newPerm)
-          // Check if the serialized combination is unique
-          if (!seen.has(serialized)) {
-            // Add it to the set of seen combinations
-            seen.add(serialized)
-            // Add the new combination to the list of new combinations
-            newCombinations.push(newPerm)
-          }
-        } else {
-          // Add incomplete combinations to the list for further processing
-          newCombinations.push(newPerm)
-        }
-      }
-    }
-    // Update the list of combinations for the next schema iteration
-    combinations = newCombinations
-  }
-
-  // Return the unique combinations
-  return combinations
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './combinationsByBoundwitness.ts'
-export * from './combinationsBySchema.ts'
-export * from './intraBoundwitnessSchemaCombinations.ts'

package/src/intraBoundwitnessSchemaCombinations.ts

@@ -1,56 +0,0 @@
-import { asHash, type Hash } from '@xylabs/sdk-js'
-import type { BoundWitness } from '@xyo-network/boundwitness-model'
-import type { Schema } from '@xyo-network/payload-model'
-
-/**
- * Returns all the possible combinations of payloads for the supplied schemas within the bound witness
- * @param boundwitness The bound witness to search
- * @param schemas The schemas to search for unique combinations of
- * @returns The payload hashes corresponding to the unique combinations of the supplied schemas
- */
-export const intraBoundwitnessSchemaCombinations = (boundwitness: BoundWitness, schemas: Schema[]): Hash[][] => {
-  // Map to store the indices of each element in the source array
-  const indexMap: Record<string, number[]> = {}
-
-  // Populate the index map with positions of each element
-  for (const [index, element] of boundwitness.payload_schemas.entries()) {
-    if (!indexMap[element]) {
-      indexMap[element] = []
-    }
-    indexMap[element].push(index)
-  }
-
-  // Initialize an array to store unique combinations
-  let uniqueCombinations = [[]] as number[][]
-
-  // Iterate over each element in the target array
-  for (const element of schemas) {
-    const newCombinations: number[][] = []
-    // Get the array of indices for the current element
-    const indices = indexMap[element] || []
-
-    // Iterate over existing combinations
-    for (const combination of uniqueCombinations) {
-      // Iterate over each index in the indices array
-      for (const index of indices) {
-        // Check if the index is already in the combination
-        if (!combination.includes(index)) {
-          const newCombination = [...combination, index]
-          // Only add the new combination if its length matches the current target index
-          if (newCombination.length === schemas.indexOf(element) + 1) {
-            newCombinations.push(newCombination)
-          }
-        }
-      }
-    }
-
-    // Update the unique combinations for the next iteration
-    uniqueCombinations = newCombinations
-  }
-
-  return uniqueCombinations.map((indexes) => {
-    return indexes.map((index) => {
-      return asHash(boundwitness.payload_hashes[index], true)
-    })
-  })
-}