@qrkit/bc-ur 2.0.0-beta.9-qrkit.1

package/src/helpers/utils.ts

@@ -0,0 +1,135 @@
+import Xoshiro from "../xoshiro.js";
+import { crc32 } from "./crc32.js";
+import { stringToUint8Array, toUint8Array } from "./uintArrayHelper.js";
+
+export const partition = (s: string, n: number): string[] =>
+  s.match(new RegExp(".{1," + n + "}", "g")) || [s];
+
+export const split = (
+  s: Uint8Array,
+  length: number
+): [Uint8Array, Uint8Array] => [s.slice(0, -length), s.slice(-length)];
+
+export const getCRC = (message: Uint8Array): number => crc32(message);
+
+export const getCRCHex = (message: Uint8Array): string =>
+  crc32(message).toString(16).padStart(8, "0");
+
+export const toUint32 = (number: number): number => number >>> 0;
+
+export const intToBytes = (num: number): Uint8Array => {
+  const arr = new ArrayBuffer(4); // an Int32 takes 4 bytes
+  const view = new DataView(arr);
+
+  view.setUint32(0, num, false); // byteOffset = 0; litteEndian = false
+
+  return toUint8Array(arr);
+};
+
+export const arraysEqual = (ar1: number[], ar2: number[]): boolean => {
+  if (ar1.length !== ar2.length) {
+    return false;
+  }
+
+  return ar1.every((el) => ar2.includes(el));
+};
+
+/**
+ * Checks if ar1 contains all elements of ar2
+ * @param ar1 the outer array
+ * @param ar2 the array to be contained in ar1
+ */
+export const arrayContains = (ar1: number[], ar2: number[]): boolean => {
+  return ar2.every((v) => ar1.includes(v));
+};
+
+/**
+ * Returns the difference array of  `ar1` - `ar2`
+ */
+export const setDifference = (ar1: number[], ar2: number[]): number[] => {
+  return ar1.filter((x) => ar2.indexOf(x) < 0);
+};
+
+export const bufferXOR = (a: Uint8Array, b: Uint8Array): Uint8Array => {
+  const length = Math.max(a.length, b.length);
+  const uInt8Array = new Uint8Array(length);
+
+  for (let i = 0; i < length; ++i) {
+    uInt8Array[i] = a[i] ^ b[i];
+  }
+
+  return uInt8Array;
+};
+
+export const makeMessage = (
+  length: number,
+  seed: string = "Wolf"
+): Uint8Array => {
+  const rng = new Xoshiro(stringToUint8Array(seed));
+
+  return new Uint8Array(rng.nextData(length));
+};
+
+
+
+/// Set operations
+/// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/difference#browser_compatibility
+
+/**
+ * Returns the union of two sets.
+ * @param set1 - The first set.
+ * @param set2 - The second set.
+ * @returns A new set containing all unique elements from both sets.
+ */
+export const union = <T>(set1: Set<T>, set2: Set<T>): Set<T> => {
+  return new Set([...set1, ...set2]);
+};
+
+/**
+ * Returns the intersection of two sets.
+ * @param set1 - The first set.
+ * @param set2 - The second set.
+ * @returns A new set containing elements present in both sets.
+ */
+export const intersection = <T>(set1: Set<T>, set2: Set<T>): Set<T> => {
+  return new Set([...set1].filter((x) => set2.has(x)));
+};
+
+/**
+ * Returns the difference of two sets (set1 - set2).
+ * @param set1 - The first set.
+ * @param set2 - The second set.
+ * @returns A new set containing elements in set1 that are not in set2.
+ */
+export const difference = <T>(set1: Set<T>, set2: Set<T>): Set<T> => {
+  return new Set([...set1].filter((x) => !set2.has(x)));
+};
+
+/**
+ * Returns the symmetric difference of two sets.
+ * @param set1 - The first set.
+ * @param set2 - The second set.
+ * @returns A new set containing elements in either set1 or set2, but not in both.
+ */
+export const symmetricDifference = <T>(set1: Set<T>, set2: Set<T>): Set<T> => {
+  return new Set([
+    ...[...set1].filter((x) => !set2.has(x)),
+    ...[...set2].filter((x) => !set1.has(x)),
+  ]);
+};
+
+/**
+ * Checks if set1 is a subset of set2.
+ * @param sub - The potential subset.
+ * @param container - The set to check against.
+ * @returns True if set1 is a subset of set2, otherwise false.
+ */
+export const isSubset = <T>(sub: Set<T>, container: Set<T>): boolean => {
+  return [...sub].every((x) => container.has(x));
+};
+
+export function assert(condition: boolean, message?: string): void {
+  if (!condition) {
+    throw new Error(message || "Assertion failed");
+  }
+}

package/src/index-react-native.ts

@@ -0,0 +1,12 @@
+/**
+ *  This is for react-native compatibility
+ *  In Expo SDK 51 (React Native 74), Hermes supports TextEncoder natively but not TextDecoder.
+ *  Latest version of Expo 52 has added TextDecoder support for Hermes. But it is still unsupported in React Native 77,
+ * 
+ *  So lets inject TextDecoder polyfill for React Native if it is not supported
+ */
+import "@bacons/text-decoder/install";
+
+// Export everything from the main index file
+//@ts-ignore
+export * from "./index.js";

package/src/index.ts

@@ -0,0 +1,44 @@
+import { UR } from "./classes/UR.js"
+import { UrRegistry } from "./registry.js"
+import { registryItemFactory, RegistryItemBase, isRegistryItem } from "./classes/RegistryItem.js"
+import { UrFountainEncoder } from "./classes/UrFountainEncoder.js"
+import { UrFountainDecoder } from "./classes/UrFountainDecoder.js"
+import { FountainEncoder } from "./classes/FountainEncoder.js"
+import { FountainDecoder } from "./classes/FountainDecoder.js"
+import { defaultEncoders, dataPipeline } from "./encodingMethods/index.js"
+
+// Encodings
+import { CborEncoding } from "./encodingMethods/CborEncoding.js"
+import { BytewordEncoding } from "./encodingMethods/BytewordEncoding.js"
+import { HexEncoding } from "./encodingMethods/HexEncoding.js"
+
+// CBOR2 library
+import * as cbor2 from "./wrappers/cbor2.js";
+
+export {
+  UrRegistry,
+  registryItemFactory,
+  RegistryItemBase,
+  isRegistryItem,
+  UR,
+  UrFountainDecoder,
+  UrFountainEncoder,
+  FountainDecoder,
+  FountainEncoder,
+  CborEncoding,
+  BytewordEncoding,
+  HexEncoding,  
+  defaultEncoders,
+  dataPipeline,
+  cbor2,
+}
+
+// Export types
+import type { RegistryItem, RegistryItemClass } from "./classes/RegistryItem.js"
+import type { DecodeOptions as DecodeOptionsType, EncodeOptions as EncodeOptionsType, CommentOptions as CommentOptionsType } from "./wrappers/cbor2.js";
+export namespace cbor2Types {
+  export type DecodeOptions = DecodeOptionsType;
+  export type EncodeOptions = EncodeOptionsType;
+  export type CommentOptions = CommentOptionsType;
+}
+export type { RegistryItem, RegistryItemClass }

package/src/interfaces/IEncodingMethod.ts

@@ -0,0 +1,10 @@
+import { EncodingMethodName } from "../enums/EncodingMethodName.js";
+
+/**
+ * Encoding method that defines the incoming type T and the outgoing type U
+ */
+export interface IEncodingMethod<T, U> {
+  name: EncodingMethodName | string;
+  encode(payload: T, config?: unknown): U;
+  decode(payload: U, config?: unknown): T;
+}

package/src/registry.ts

@@ -0,0 +1,146 @@
+import { RegistryItemClass } from "./classes/RegistryItem.js";
+import {
+  Tag,
+} from "./wrappers/cbor2.js";
+
+type Registry = Map<string, RegistryItemClass>;
+
+export class URRegistryClass {
+  private static instance: URRegistryClass;
+  private registry: Registry = new Map();
+  private tagMap: Map<number, string> = new Map();
+  private loggingEnabled: boolean;
+
+  private constructor(
+    items: RegistryItemClass[] = [],
+    loggingEnabled: boolean = true
+  ) {
+    this.loggingEnabled = loggingEnabled;
+    this.addItems(items);
+  }
+
+  public static getInstance(
+    items: RegistryItemClass[] = [],
+    loggingEnabled: boolean = true
+  ): URRegistryClass {
+    if (!URRegistryClass.instance) {
+      URRegistryClass.instance = new URRegistryClass(items, loggingEnabled);
+    }
+    return URRegistryClass.instance;
+  }
+
+  public setLoggingEnabled(enabled: boolean): void {
+    this.loggingEnabled = enabled;
+  }
+
+  private log(message: string): void {
+    if (this.loggingEnabled) {
+      console.warn(message);
+    }
+  }
+
+  public addItem(item: RegistryItemClass): void {
+    if (this.registry.has(item.URType)) {
+      this.log(
+        `Warning: Overwriting existing item with URType: ${item.URType}`
+      );
+    }
+    if (this.tagMap.has(item.tag)) {
+      this.log(`Warning: Tag collision detected for tag: ${item.tag}`);
+    }
+    this.registry.set(item.URType, item);
+
+    // Register to CBOR decoder only if it has a tag
+    if (!Number.isNaN(item.tag)) {
+      this.tagMap.set(item.tag, item.URType);
+      Tag.registerDecoder(item.tag, (tag: Tag, opts: any) => {
+        return item.fromCBORData.bind(item)(
+          tag.contents,
+          item.allowKeysNotInMap,
+          opts
+        );
+      });
+    }
+  }
+
+  public addItemOnce(item: RegistryItemClass): void {
+    // If we already have the item in the registry, do nothing
+    if (this.registry.has(item.URType) || this.tagMap.has(item.tag)) {
+      // Check if its the same item
+      const existingItem = this.registry.get(item.URType);
+      if (existingItem !== item) {
+        this.log(
+          `Warning: Resgistry already has an item with URType: ${item.URType} but it seems to be a different instance`
+        );
+        this.log(`Existing item: ${existingItem}`);
+        this.log(`New item: ${item}`);
+      }
+      return;
+    }
+
+    // Otherwise, add the item
+    this.addItem(item);
+  }
+
+  public addItems(items: RegistryItemClass[]): void {
+    items.forEach((item) => this.addItem(item));
+  }
+
+  public queryByTag(tag: number): RegistryItemClass | undefined {
+    const URType = this.tagMap.get(tag);
+    return URType ? this.registry.get(URType) : undefined;
+  }
+
+  public queryByURType(URType: string): RegistryItemClass | undefined {
+    return this.registry.get(URType);
+  }
+
+  /**
+   * Removes an item from the registry based on its URType, tag, or item instance.
+   * @param findItem - The item to be removed. It can be an instance of RegistryItemClass, a URType string, or a tag number.
+   */
+  public removeItem(findItem: RegistryItemClass | string | number): void {
+    let foundItem: RegistryItemClass | undefined;
+    if (typeof findItem === "string") {
+      foundItem = this.queryByURType(findItem);
+      if (!foundItem) {
+        this.log(`Warning: No item found with URType: ${findItem}`);
+        return;
+      }
+    } else if (typeof findItem === "number") {
+      foundItem = this.queryByTag(findItem);
+      if (!foundItem) {
+        this.log(`Warning: No item found with tag: ${findItem}`);
+        return;
+      }
+    } else {
+      // Check if the item is in the registry
+      const URType = findItem.URType;
+      if (this.registry.has(URType)) {
+        foundItem = findItem;
+      } else {
+        this.log(`Warning: Item not found in registry with type: ${URType}`);
+        return;
+      }
+    }
+
+    // Remove it from registry
+    this.registry.delete(foundItem.URType);
+    this.tagMap.delete(foundItem.tag);
+    Tag.clearDecoder(foundItem.tag);
+  }
+
+  public clearRegistry(): void {
+    this.registry.forEach((item) => {
+      Tag.clearDecoder(item.tag);
+    });
+    this.registry.clear();
+    this.tagMap.clear();
+  }
+
+  public getRegistry(): Registry {
+    return this.registry;
+  }
+}
+
+export const UrRegistry = URRegistryClass.getInstance();

package/src/test.utils.ts

@@ -0,0 +1,105 @@
+import { registryItemFactory } from "./classes/RegistryItem.js";
+
+// Define a nested registry items
+interface IUser {
+  id: number;
+  name: string;
+  email?: string;
+  phone?: string;
+  address?: string;
+  [key: string]: any;
+}
+export class User extends registryItemFactory({
+  tag: 111,
+  URType: "user",
+  CDDL: `
+          user = #6.111({
+              id: uint,
+              name: text,
+              ? email: text,
+              ? phone: text,
+              ? address: text
+          })
+        `,
+}) {
+  private user: IUser;
+
+  constructor(user: IUser) {
+    super(user);
+    this.user = user;
+  }
+
+  verifyInput(input: any) {
+    let reasons: Error[] = [];
+
+    if (!input.id) {
+      reasons.push(new Error("ID is required"));
+    } else {
+      if (typeof input.id !== "number") {
+        reasons.push(new Error("ID should be a number"));
+      }
+    }
+
+    if (!input.name) {
+      reasons.push(new Error("Name is required"));
+    } else {
+      if (typeof input.name !== "string") {
+        reasons.push(new Error("Name should be a string"));
+      }
+    }
+
+    const valid = reasons.length === 0;
+    return { valid, reasons };
+  }
+}
+
+// Parent class
+interface IUserCollection {
+  name: string;
+  users: User[];
+}
+
+const UserCollectionType = {
+  tag: 112,
+  URType: "user-collection",
+  CDDL: `
+          user-collection = #6.112({
+            name: text,
+            users: [+ #6.112(user)]
+          })
+        `,
+};
+
+export class UserCollection extends registryItemFactory(UserCollectionType) {
+  constructor(private userCollection: IUserCollection) {
+    super(userCollection);
+  }
+
+  verifyInput(input: any) {
+    let reasons: Error[] = [];
+
+    if (!input.name) {
+      reasons.push(new Error("Name is required"));
+    }
+
+    if (typeof input.name !== "string") {
+      reasons.push(new Error("Name should be a string"));
+    }
+
+    if (input.users) {
+      // Check its array
+      if (!Array.isArray(input.users)) {
+        reasons.push(new Error("Users should be an array"));
+      } else {
+        input.users.forEach((user: any) => {
+          if (!(user instanceof User)) {
+            reasons.push(new Error("Users should be an array of User"));
+          }
+        });
+      }
+    }
+
+    const valid = reasons.length === 0;
+    return { valid, reasons };
+  }
+}

package/src/wrappers/cbor2-cjs.cts

@@ -0,0 +1,6 @@
+// This is the common ground for both esm and commonjs modules
+// To overcome dual-package-hazard
+//@ts-ignore
+export { decode, encode, Tag, registerEncoder, comment, diagnose } from "./cbor2Wrapper.js";
+//@ts-ignore
+export type { DecodeOptions, EncodeOptions, CommentOptions } from "./cbor2Wrapper.js";

package/src/wrappers/cbor2-deno.mts

@@ -0,0 +1,6 @@
+// If you need a provide an ESM dialect that doesn't support CommonJS (eg, deno, browser, etc), then you can do this:
+// No dual package hazard here
+//@ts-ignore
+export { decode, encode, Tag, registerEncoder, comment, diagnose } from "./cbor2Wrapper.js";
+//@ts-ignore
+export type { DecodeOptions, EncodeOptions, CommentOptions } from "./cbor2Wrapper.js";

package/src/wrappers/cbor2.ts

@@ -0,0 +1,7 @@
+// ESM consumers should stay entirely within the ESM output tree.
+// The CommonJS build gets its own wrapper entry via `cbor2-cjs.cts`.
+
+//@ts-ignore
+export { decode, encode, Tag, registerEncoder, comment, diagnose } from "./cbor2Wrapper.js";
+//@ts-ignore
+export type { DecodeOptions, EncodeOptions, CommentOptions } from "./cbor2Wrapper.js";

package/src/wrappers/cbor2Wrapper.ts

@@ -0,0 +1,14 @@
+import type {
+  DecodeOptions,
+  EncodeOptions,
+  CommentOptions,
+//@ts-ignore
+} from 'cbor2' with { 'resolution-mode': 'import' };
+
+//@ts-ignore
+import { decode, encode, Tag, comment, diagnose } from 'cbor2';
+//@ts-ignore
+import { registerEncoder } from 'cbor2/encoder';
+
+export { decode, encode, Tag, registerEncoder, comment, diagnose };
+export type { DecodeOptions, EncodeOptions, CommentOptions };

package/src/xoshiro.ts

@@ -0,0 +1,66 @@
+import { sha256 } from "./helpers/sha256.js";
+
+export const sha256Hash = (data) => {
+  return sha256(data);
+};
+
+const MAX_UINT64 = BigInt("0xffffffffffffffff");
+
+const rotl = (x: bigint, k: number): bigint =>
+  (x << BigInt(k) | x >> BigInt(64 - k)) & MAX_UINT64;
+
+export default class Xoshiro {
+  private s: bigint[];
+
+  constructor(seed: Uint8Array) {
+    const digest = sha256Hash(seed);
+
+    this.s = [0n, 0n, 0n, 0n];
+    this.setS(digest);
+  }
+
+  private setS = (digest: Uint8Array) => {
+    for (let i = 0; i < 4; i++) {
+      let o = i * 8;
+      let v = 0n;
+      for (let n = 0; n < 8; n++) {
+        v = (v << 8n) | BigInt(digest[o + n]);
+      }
+      this.s[i] = v & MAX_UINT64;
+    }
+  };
+
+  private roll = (): bigint => {
+    const result =
+      ((rotl((this.s[1] * 5n) & MAX_UINT64, 7) * 9n) & MAX_UINT64);
+
+    const t = (this.s[1] << 17n) & MAX_UINT64;
+
+    this.s[2] ^= this.s[0];
+    this.s[3] ^= this.s[1];
+    this.s[1] ^= this.s[2];
+    this.s[0] ^= this.s[3];
+
+    this.s[2] ^= t;
+    this.s[3] = rotl(this.s[3], 45);
+
+    return result;
+  };
+
+  next = (): bigint => {
+    return this.roll();
+  };
+
+  nextDouble = (): number => {
+    return Number(this.roll()) / Number(MAX_UINT64 + 1n);
+  };
+
+  nextInt = (low: number, high: number): number => {
+    return Math.floor(this.nextDouble() * (high - low + 1) + low);
+  };
+
+  nextByte = () => this.nextInt(0, 255);
+
+  nextData = (count: number) =>
+    [...new Array(count)].map(() => this.nextByte());
+}