@fleet-sdk/serializer 0.2.0

package/src/types/descriptors.ts

@@ -0,0 +1,105 @@
+import { SType } from "./base";
+import { SCollType, STupleType } from "./generics";
+import { SUnitType } from "./monomorphics";
+import {
+  SBigIntType,
+  SBoolType,
+  SByteType,
+  SGroupElementType,
+  SIntType,
+  SLongType,
+  SShortType,
+  SSigmaPropType
+} from "./primitives";
+
+export const constructorCode = Object.freeze({
+  embeddable: 0,
+
+  simpleColl: 1,
+  nestedColl: 2,
+
+  option: 3,
+  optionCollection: 4,
+
+  pairOne: 5,
+  pairTwo: 6,
+  symmetricPair: 7,
+  genericTuple: 8
+});
+
+const MAX_PRIMITIVE_TYPE_CODE = 0x0b;
+export const PRIMITIVE_TYPE_RANGE = MAX_PRIMITIVE_TYPE_CODE + 0x01;
+const typeCodeOf = (constructor: number) => PRIMITIVE_TYPE_RANGE * constructor;
+
+type Descriptor = { code: number; embeddable: boolean };
+
+const collDescriptor = Object.freeze({
+  code: typeCodeOf(constructorCode.simpleColl),
+  embeddable: false,
+  simpleCollTypeCode: typeCodeOf(constructorCode.simpleColl),
+  nestedCollTypeCode: typeCodeOf(constructorCode.nestedColl)
+}) satisfies Descriptor;
+
+const tupleDescriptor = Object.freeze({
+  code: typeCodeOf(constructorCode.pairOne),
+  embeddable: false,
+  pairOneTypeCode: typeCodeOf(constructorCode.pairOne),
+  pairTwoTypeCode: typeCodeOf(constructorCode.pairTwo),
+  tripleTypeCode: typeCodeOf(constructorCode.pairTwo),
+  symmetricPairTypeCode: typeCodeOf(constructorCode.symmetricPair),
+  quadrupleTypeCode: typeCodeOf(constructorCode.symmetricPair),
+  genericTupleTypeCode: typeCodeOf(constructorCode.genericTuple)
+}) satisfies Descriptor;
+
+export const descriptors = {
+  bool: new SBoolType(),
+  byte: new SByteType(),
+  short: new SShortType(),
+  int: new SIntType(),
+  long: new SLongType(),
+  bigInt: new SBigIntType(),
+  groupElement: new SGroupElementType(),
+  sigmaProp: new SSigmaPropType(),
+  unit: new SUnitType(),
+  coll: collDescriptor,
+  tuple: tupleDescriptor
+} satisfies { [key: string]: Descriptor };
+
+export function isColl(type: SType): type is SCollType {
+  return (
+    type.code >= descriptors.coll.simpleCollTypeCode &&
+    type.code <= descriptors.coll.nestedCollTypeCode + MAX_PRIMITIVE_TYPE_CODE
+  );
+}
+
+export function isTuple(type: SType): type is STupleType {
+  return (
+    type.code >= descriptors.tuple.pairOneTypeCode &&
+    type.code <= descriptors.tuple.genericTupleTypeCode
+  );
+}
+
+export function getPrimitiveType(typeCode: number) {
+  switch (typeCode) {
+    case descriptors.bool.code:
+      return descriptors.bool;
+    case descriptors.byte.code:
+      return descriptors.byte;
+    case descriptors.short.code:
+      return descriptors.short;
+    case descriptors.int.code:
+      return descriptors.int;
+    case descriptors.long.code:
+      return descriptors.long;
+    case descriptors.bigInt.code:
+      return descriptors.bigInt;
+    case descriptors.groupElement.code:
+      return descriptors.groupElement;
+    case descriptors.sigmaProp.code:
+      return descriptors.sigmaProp;
+    default:
+      throw new Error(
+        `The type code '0x${typeCode.toString(16)}' is not a valid primitive type code.`
+      );
+  }
+}

package/src/types/generics.ts

@@ -0,0 +1,42 @@
+import { hex } from "@fleet-sdk/crypto";
+import { SGenericType, SType } from "./base";
+import { descriptors } from "./descriptors";
+
+export class SCollType<T extends SType = SType> extends SGenericType<T> {
+  get code(): number {
+    return descriptors.coll.code;
+  }
+
+  override coerce<I, O>(elements: I[]): O[] | Uint8Array {
+    if (this.elementsType.code === descriptors.byte.code && !(elements instanceof Uint8Array)) {
+      return typeof elements === "string"
+        ? hex.decode(elements)
+        : Uint8Array.from(elements as ArrayLike<number>);
+    }
+
+    return elements.map((el) => this.elementsType.coerce(el)) as O[];
+  }
+
+  toString(): string {
+    return `SColl[${this.elementsType.toString()}]`;
+  }
+}
+
+export class STupleType<T extends SType[] = SType[]> extends SGenericType<T> {
+  get code(): number {
+    return descriptors.tuple.code;
+  }
+
+  override coerce<I, O>(elements: I[]): O[] {
+    const output = new Array(elements.length);
+    for (let i = 0; i < elements.length; i++) {
+      output[i] = this.elementsType[i].coerce(elements[i]);
+    }
+
+    return output;
+  }
+
+  toString(): string {
+    return `(${this.elementsType.map((el) => el.toString()).join(", ")})`;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,18 @@
+export * from "./base";
+export * from "./primitives";
+export { isColl, isTuple } from "./descriptors";
+export * from "./generics";
+export * from "./monomorphics";
+export {
+  SByte,
+  SBool,
+  SShort,
+  SInt,
+  SLong,
+  SBigInt,
+  SGroupElement,
+  SSigmaProp,
+  SUnit,
+  SColl,
+  SPair
+} from "./constructors";

package/src/types/monomorphics.ts

@@ -0,0 +1,11 @@
+import { SMonomorphicType } from "./base";
+
+export class SUnitType extends SMonomorphicType<undefined> {
+  get code(): 0x62 {
+    return 0x62;
+  }
+
+  toString(): string {
+    return "SUnit";
+  }
+}

package/src/types/primitives.ts

@@ -0,0 +1,97 @@
+import { ensureBigInt } from "@fleet-sdk/common";
+import { hex } from "@fleet-sdk/crypto";
+import { SConstant } from "../sigmaConstant";
+import { SPrimitiveType } from "./base";
+import { BigIntInput, ByteInput } from "./constructors";
+
+export class SBoolType extends SPrimitiveType<boolean> {
+  get code(): 0x01 {
+    return 0x01;
+  }
+
+  toString(): string {
+    return "SBool";
+  }
+}
+
+export class SByteType extends SPrimitiveType<number> {
+  get code(): 0x02 {
+    return 0x02;
+  }
+
+  toString(): string {
+    return "SByte";
+  }
+}
+
+export class SShortType extends SPrimitiveType<number> {
+  get code(): 0x03 {
+    return 0x03;
+  }
+
+  toString(): string {
+    return "SShort";
+  }
+}
+
+export class SIntType extends SPrimitiveType<number> {
+  get code(): 0x04 {
+    return 0x04;
+  }
+
+  toString(): string {
+    return "SInt";
+  }
+}
+
+export class SLongType extends SPrimitiveType<BigIntInput, bigint> {
+  get code(): 0x05 {
+    return 0x05;
+  }
+
+  override coerce(data: BigIntInput): bigint {
+    return ensureBigInt(data);
+  }
+
+  toString(): string {
+    return "SLong";
+  }
+}
+
+export class SBigIntType extends SPrimitiveType<string | bigint, bigint> {
+  get code(): number {
+    return 0x06;
+  }
+
+  override coerce(data: BigIntInput): bigint {
+    return ensureBigInt(data);
+  }
+
+  toString(): string {
+    return "SBigInt";
+  }
+}
+
+export class SGroupElementType extends SPrimitiveType<ByteInput, Uint8Array> {
+  get code(): 0x07 {
+    return 0x07;
+  }
+
+  override coerce(data: ByteInput): Uint8Array {
+    return typeof data === "string" ? hex.decode(data) : data;
+  }
+
+  toString(): string {
+    return "SGroupElement";
+  }
+}
+
+export class SSigmaPropType extends SPrimitiveType<SConstant<Uint8Array>> {
+  get code(): 0x08 {
+    return 0x08;
+  }
+
+  toString(): string {
+    return "SSigmaProp";
+  }
+}