@fleet-sdk/serializer 0.2.2 → 0.3.0

package/src/serializers/transactionSerializer.ts

@@ -1,76 +0,0 @@
-import {
-  Amount,
-  BoxCandidate,
-  ContextExtension,
-  DataInput,
-  isDefined,
-  UnsignedInput
-} from "@fleet-sdk/common";
-import { SigmaWriter } from "../coders";
-import { serializeBox } from "./boxSerializer";
-
-export type MinimalUnsignedTransaction = {
-  inputs: readonly UnsignedInput[];
-  dataInputs: readonly DataInput[];
-  outputs: readonly BoxCandidate<Amount>[];
-};
-
-export function serializeTransaction(transaction: MinimalUnsignedTransaction): SigmaWriter {
-  const writer = new SigmaWriter(100_000);
-
-  // write inputs
-  writer.writeVLQ(transaction.inputs.length);
-  transaction.inputs.map((input) => writeInput(writer, input));
-
-  // write data inputs
-  writer.writeVLQ(transaction.dataInputs.length);
-  transaction.dataInputs.map((dataInput) => writer.writeHex(dataInput.boxId));
-
-  // write distinct token IDs
-  const distinctTokenIds = getDistinctTokenIds(transaction.outputs);
-  writer.writeVLQ(distinctTokenIds.length);
-  distinctTokenIds.map((tokenId) => writer.writeHex(tokenId));
-
-  // write outputs
-  writer.writeVLQ(transaction.outputs.length);
-  transaction.outputs.map((output) => serializeBox(output, writer, distinctTokenIds));
-
-  return writer;
-}
-
-function writeInput(writer: SigmaWriter, input: UnsignedInput): void {
-  writer.writeHex(input.boxId);
-  writer.write(0); // empty proof
-  writeExtension(writer, input.extension);
-}
-
-function writeExtension(writer: SigmaWriter, extension: ContextExtension): void {
-  const keys = Object.keys(extension);
-  let length = 0;
-
-  for (const key of keys) {
-    const ext = extension[key as unknown as keyof ContextExtension];
-    if (isDefined(ext)) {
-      length++;
-    }
-  }
-
-  writer.writeVLQ(length);
-  if (length == 0) {
-    return;
-  }
-
-  for (const key of keys) {
-    const ext = extension[key as unknown as keyof ContextExtension];
-    if (isDefined(ext)) {
-      writer.writeVLQ(Number(key)).writeHex(ext);
-    }
-  }
-}
-
-function getDistinctTokenIds(outputs: readonly BoxCandidate<Amount>[]) {
-  const tokenIds = new Set<string>();
-  outputs.flatMap((output) => output.assets.map((asset) => tokenIds.add(asset.tokenId)));
-
-  return Array.from(tokenIds);
-}

package/src/serializers/typeSerializer.ts

@@ -1,148 +0,0 @@
-import { assert, first, last } from "@fleet-sdk/common";
-import { SigmaReader, SigmaWriter } from "../coders";
-import { isColl, isTuple, SCollType, STupleType, SType } from "../types";
-import {
-  constructorCode,
-  descriptors,
-  getPrimitiveType,
-  PRIMITIVE_TYPE_RANGE
-} from "../types/descriptors";
-
-export class TypeSerializer {
-  static serialize(type: SType, writer: SigmaWriter) {
-    if (type.embeddable) {
-      writer.write(type.code);
-    } else if (type.code === descriptors.unit.code) {
-      writer.write(type.code);
-    } else if (isColl(type)) {
-      if (type.elementsType.embeddable) {
-        writer.write(descriptors.coll.simpleCollTypeCode + type.elementsType.code);
-      } else if (isColl(type.elementsType)) {
-        const nestedColl = type.elementsType;
-        if (nestedColl.elementsType.embeddable) {
-          writer.write(descriptors.coll.nestedCollTypeCode + nestedColl.elementsType.code);
-        } else {
-          writer.write(descriptors.coll.simpleCollTypeCode);
-          this.serialize(nestedColl, writer);
-        }
-      } else {
-        writer.write(descriptors.coll.simpleCollTypeCode);
-        this.serialize(type.elementsType, writer);
-      }
-    } else if (isTuple(type)) {
-      switch (type.elementsType.length) {
-        case 2: {
-          const left = first(type.elementsType);
-          const right = last(type.elementsType);
-
-          if (left.embeddable) {
-            if (left.code === right.code) {
-              // Symmetric pair of primitive types (`(Int, Int)`, `(Byte,Byte)`, etc.)
-              writer.write(descriptors.tuple.symmetricPairTypeCode + left.code);
-            } else {
-              // Pair of types where first is primitive (`(_, Int)`)
-              writer.write(descriptors.tuple.pairOneTypeCode + left.code);
-              this.serialize(right, writer);
-            }
-          } else if (right.embeddable) {
-            // Pair of types where second is primitive (`(Int, _)`)
-            writer.write(descriptors.tuple.pairTwoTypeCode + right.code);
-            this.serialize(left, writer);
-          } else {
-            // Pair of non-primitive types (`((Int, Byte), (Boolean,Box))`, etc.)
-            writer.write(descriptors.tuple.pairOneTypeCode);
-            this.serialize(left, writer);
-            this.serialize(right, writer);
-          }
-
-          return;
-        }
-        case 3:
-          writer.write(descriptors.tuple.tripleTypeCode);
-          break;
-        case 4:
-          writer.write(descriptors.tuple.quadrupleTypeCode);
-          break;
-        default: {
-          const len = type.elementsType.length;
-          assert(len >= 2 && len <= 255, "Invalid type: tuples must have between 2 and 255 items.");
-
-          // Generic tuple
-          writer.write(descriptors.tuple.genericTupleTypeCode);
-          writer.writeVLQ(len);
-        }
-      }
-
-      for (let i = 0; i < type.elementsType.length; i++) {
-        this.serialize(type.elementsType[i], writer);
-      }
-    } else {
-      throw new Error("Serialization error: type not implemented.");
-    }
-  }
-
-  static deserialize(r: SigmaReader): SType {
-    const byte = r.readByte();
-    assert(byte > 0, `Parsing Error: Unexpected type code '0x${byte.toString(16)}'`);
-
-    if (byte < descriptors.tuple.genericTupleTypeCode) {
-      const ctorCode = Math.floor(byte / PRIMITIVE_TYPE_RANGE);
-      const embdCode = Math.floor(byte % PRIMITIVE_TYPE_RANGE);
-
-      switch (ctorCode) {
-        case constructorCode.embeddable: {
-          return getPrimitiveType(embdCode);
-        }
-        case constructorCode.simpleColl: {
-          const internal = embdCode === 0 ? this.deserialize(r) : getPrimitiveType(embdCode);
-
-          return new SCollType(internal);
-        }
-        case constructorCode.nestedColl: {
-          return new SCollType(new SCollType(getPrimitiveType(embdCode)));
-        }
-        case constructorCode.pairOne: {
-          const internal =
-            embdCode === 0
-              ? [this.deserialize(r), this.deserialize(r)] // Pair of non-primitive types (`((Int, Byte), (Boolean,Box))`, etc.)
-              : [getPrimitiveType(embdCode), this.deserialize(r)]; // Pair of types where first is primitive (`(_, Int)`)
-
-          return new STupleType(internal);
-        }
-        case constructorCode.pairTwo: {
-          const internal =
-            embdCode === 0
-              ? [this.deserialize(r), this.deserialize(r), this.deserialize(r)] // Triple of types
-              : [this.deserialize(r), getPrimitiveType(embdCode)];
-
-          return new STupleType(internal);
-        }
-        case constructorCode.symmetricPair: {
-          const internal =
-            embdCode === 0
-              ? [this.deserialize(r), this.deserialize(r), this.deserialize(r), this.deserialize(r)] // Quadruple of types
-              : [getPrimitiveType(embdCode), getPrimitiveType(embdCode)]; // Symmetric pair of primitive types (`(Int, Int)`, `(Byte,Byte)`, etc.)
-
-          return new STupleType(internal);
-        }
-      }
-    } else {
-      switch (byte) {
-        case descriptors.tuple.genericTupleTypeCode: {
-          const len = r.readVlq();
-          const wrapped = new Array<SType>(len);
-          for (let i = 0; i < len; i++) {
-            wrapped[i] = this.deserialize(r);
-          }
-
-          return new STupleType(wrapped);
-        }
-        case descriptors.unit.code: {
-          return descriptors.unit;
-        }
-      }
-    }
-
-    throw new Error("Not implemented.");
-  }
-}

package/src/sigmaConstant.ts

@@ -1,59 +0,0 @@
-import { BytesInput, hex } from "@fleet-sdk/crypto";
-import { SigmaReader, SigmaWriter } from "./coders";
-import { DataSerializer } from "./serializers/dataSerializer";
-import { TypeSerializer } from "./serializers/typeSerializer";
-import { SType } from "./types";
-
-export const MAX_CONSTANT_LENGTH = 4096;
-
-export class SConstant<D = unknown, T extends SType = SType> {
-  readonly #type: T;
-  readonly #data: D;
-
-  constructor(type: T, data: D) {
-    this.#type = type;
-    this.#data = type.coerce(data) as D;
-  }
-
-  static from<D, T extends SType = SType>(bytes: BytesInput): SConstant<D, T> {
-    const reader = new SigmaReader(bytes);
-    const type = TypeSerializer.deserialize(reader);
-    const data = DataSerializer.deserialize(type, reader);
-
-    return new SConstant(type as T, data as D);
-  }
-
-  get type(): T {
-    return this.#type;
-  }
-
-  get data(): D {
-    return this.#data;
-  }
-
-  toBytes(): Uint8Array {
-    const writer = new SigmaWriter(MAX_CONSTANT_LENGTH);
-    TypeSerializer.serialize(this.type, writer);
-    DataSerializer.serialize(this.data, this.type, writer);
-
-    return writer.toBytes();
-  }
-
-  toHex(): string {
-    return hex.encode(this.toBytes());
-  }
-}
-
-export function parse<T>(bytes: BytesInput): T;
-export function parse<T>(bytes: BytesInput, mode: "strict"): T;
-export function parse<T>(bytes: BytesInput, mode: "safe"): T | undefined;
-export function parse<T>(bytes: BytesInput, mode: "strict" | "safe" = "strict") {
-  if (mode === "strict") return SConstant.from<T>(bytes).data;
-  if (!bytes) return;
-
-  try {
-    return SConstant.from<T>(bytes).data;
-  } catch {
-    return;
-  }
-}

package/src/types/base.ts

@@ -1,46 +0,0 @@
-export abstract class SType<I = unknown, O = I> {
-  abstract get code(): number;
-  abstract get embeddable(): boolean;
-
-  coerce(data: I): O {
-    // a bit hacky but most of types will not need a specific coercion function.
-    return data as unknown as O;
-  }
-
-  abstract toString(): string;
-}
-
-export abstract class SMonomorphicType<I, O = I> extends SType<I, O> {
-  abstract get code(): number;
-
-  get embeddable(): boolean {
-    return false;
-  }
-}
-
-export abstract class SPrimitiveType<I, O = I> extends SMonomorphicType<I, O> {
-  abstract get code(): number;
-
-  override get embeddable(): boolean {
-    return true;
-  }
-}
-
-export abstract class SGenericType<T extends SType | SType[]> extends SType {
-  readonly #internalType: T;
-
-  constructor(type: T) {
-    super();
-    this.#internalType = type;
-  }
-
-  abstract get code(): number;
-
-  get elementsType(): T {
-    return this.#internalType;
-  }
-
-  get embeddable(): boolean {
-    return false;
-  }
-}

package/src/types/constructors.test-d.ts

@@ -1,147 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-import { SConstant } from "../sigmaConstant";
-import {
-  ByteInput,
-  SBigInt,
-  SBool,
-  SByte,
-  SColl,
-  SConstructor,
-  SGroupElement,
-  SInt,
-  SLong,
-  SPair,
-  SShort,
-  SSigmaProp,
-  SUnit
-} from "./constructors";
-import { SUnitType } from "./monomorphics";
-import {
-  SBigIntType,
-  SBoolType,
-  SByteType,
-  SGroupElementType,
-  SIntType,
-  SLongType,
-  SShortType,
-  SSigmaPropType
-} from "./primitives";
-
-describe("Constructor proxies types", () => {
-  it("Should ensure correct types for monomorphics.", () => {
-    expectTypeOf(SByte).parameter(0).toMatchTypeOf<number | undefined>();
-    expectTypeOf(SByte()).toMatchTypeOf<SByteType>();
-    expectTypeOf(SByte(1)).toMatchTypeOf<SConstant<number, SByteType>>();
-
-    expectTypeOf(SBool).parameter(0).toMatchTypeOf<boolean | undefined>();
-    expectTypeOf(SBool()).toMatchTypeOf<SBoolType>();
-    expectTypeOf(SBool(true)).toMatchTypeOf<SConstant<boolean, SBoolType>>();
-
-    expectTypeOf(SShort).parameter(0).toMatchTypeOf<number | undefined>();
-    expectTypeOf(SShort()).toMatchTypeOf<SShortType>();
-    expectTypeOf(SShort(1)).toMatchTypeOf<SConstant<number, SShortType>>();
-
-    expectTypeOf(SInt).parameter(0).toMatchTypeOf<number | undefined>();
-    expectTypeOf(SInt()).toMatchTypeOf<SIntType>();
-    expectTypeOf(SInt(1)).toMatchTypeOf<SConstant<number, SIntType>>();
-
-    expectTypeOf(SLong).parameter(0).toMatchTypeOf<string | bigint | undefined>();
-    expectTypeOf(SLong()).toMatchTypeOf<SLongType>();
-    expectTypeOf(SLong(1n)).toMatchTypeOf<SConstant<bigint, SLongType>>();
-    expectTypeOf(SLong("1")).toMatchTypeOf<SConstant<bigint, SLongType>>();
-
-    expectTypeOf(SBigInt).parameter(0).toMatchTypeOf<string | bigint | undefined>();
-    expectTypeOf(SBigInt()).toMatchTypeOf<SBigIntType>();
-    expectTypeOf(SBigInt(1n)).toMatchTypeOf<SConstant<bigint, SBigIntType>>();
-    expectTypeOf(SBigInt("1")).toMatchTypeOf<SConstant<bigint, SBigIntType>>();
-
-    expectTypeOf(SGroupElement).parameter(0).toMatchTypeOf<Uint8Array | string | undefined>();
-    expectTypeOf(SGroupElement()).toMatchTypeOf<SGroupElementType>();
-    expectTypeOf(SGroupElement(Uint8Array.from([1, 2, 3]))).toMatchTypeOf<
-      SConstant<Uint8Array, SGroupElementType>
-    >();
-    expectTypeOf(SGroupElement("deadbeef")).toMatchTypeOf<
-      SConstant<Uint8Array, SGroupElementType>
-    >();
-
-    expectTypeOf(SSigmaProp).parameter(0).toMatchTypeOf<SConstant<Uint8Array> | undefined>();
-    expectTypeOf(SSigmaProp()).toMatchTypeOf<SSigmaPropType>();
-    expectTypeOf(SSigmaProp(SGroupElement("deadbeef"))).toMatchTypeOf<
-      SConstant<SConstant<Uint8Array>, SSigmaPropType>
-    >();
-
-    expectTypeOf(SUnit()).not.toMatchTypeOf<SUnitType>();
-    expectTypeOf(SUnit()).toMatchTypeOf<SConstant<undefined, SUnitType>>();
-  });
-
-  it("Should ensure correct types for generics", () => {
-    expectTypeOf(SColl(SByte)).toMatchTypeOf<SConstructor<number[], SByteType>>();
-    expectTypeOf(SColl(SBool)).toMatchTypeOf<SConstructor<boolean[], SBoolType>>();
-    expectTypeOf(SColl(SShort)).toMatchTypeOf<SConstructor<number[], SShortType>>();
-    expectTypeOf(SColl(SInt)).toMatchTypeOf<SConstructor<number[], SIntType>>();
-    expectTypeOf(SColl(SLong)).toMatchTypeOf<SConstructor<bigint[], SLongType>>();
-    expectTypeOf(SColl(SBigInt)).toMatchTypeOf<SConstructor<bigint[], SBigIntType>>();
-    expectTypeOf(SColl(SGroupElement)).toMatchTypeOf<
-      SConstructor<Uint8Array[], SGroupElementType>
-    >();
-    expectTypeOf(SColl(SSigmaProp)).toMatchTypeOf<
-      SConstructor<SConstant<Uint8Array>[], SSigmaPropType>
-    >();
-
-    expectTypeOf(
-      SColl(SPair(SColl(SByte), SColl(SByte)), [
-        [Uint8Array.from([1, 2, 3]), "deadbeef"],
-        [
-          [1, 2, 3],
-          [4, 5, 6]
-        ]
-      ]).data
-    ).toMatchTypeOf<[ByteInput | number[], ByteInput | number[]][]>();
-
-    expectTypeOf(
-      SColl(SPair(SColl(SBool), SColl(SByte)), [
-        [[true, false], "deadbeef"],
-        [
-          [false, true],
-          [4, 5, 6]
-        ]
-      ]).data
-    ).toMatchTypeOf<[boolean[], ByteInput | number[]][]>();
-
-    expectTypeOf(SColl(SBool, [true, false, true, true]).data).toMatchTypeOf<boolean[]>();
-
-    expectTypeOf(SColl(SByte, "deadbeef").data).toMatchTypeOf<Uint8Array>();
-    expectTypeOf(SColl(SByte, [1, 2]).data).toMatchTypeOf<Uint8Array>();
-    expectTypeOf(SColl(SByte, Uint8Array.from([1])).data).toMatchTypeOf<Uint8Array>();
-    expectTypeOf(SColl(SInt, [1, 2, 3]).data).toMatchTypeOf<number[]>();
-    expectTypeOf(
-      SColl(SColl(SBool), [
-        [true, false],
-        [false, false]
-      ]).data
-    ).toMatchTypeOf<boolean[][]>();
-
-    expectTypeOf(SPair(SInt(1), SBool(false)).data).toMatchTypeOf<[number, boolean]>();
-    expectTypeOf(SPair(SBool(true), SInt(1)).data).toMatchTypeOf<[boolean, number]>();
-    expectTypeOf(SPair(SInt(1), SLong("1")).data).toMatchTypeOf<[number, bigint]>();
-    expectTypeOf(SPair(SPair(SBool(true), SInt(1)), SLong("1")).data).toMatchTypeOf<
-      [[boolean, number], bigint]
-    >();
-
-    // @ts-expect-error elements should be boolean[]
-    SColl(SPair(SColl(SByte), SColl(SInt)), [[[1, 2, 3], 1]]);
-    // @ts-expect-error elements should be boolean[]
-    SColl(SBool, [true, false, true, 1]);
-    // @ts-expect-error elements should be number[]
-    SColl(SInt, Uint8Array.from([1]));
-    // @ts-expect-error elements should be number[]
-    SColl(SShort, "");
-    // @ts-expect-error elements should be number[]
-    SColl(SShort, {});
-    // @ts-expect-error elements should be boolean[][]
-    SColl(SColl(SBool), [
-      [true, false],
-      [false, "true"]
-    ]);
-  });
-});

package/src/types/constructors.ts

@@ -1,144 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isEmpty } from "@fleet-sdk/common";
-import { SConstant } from "../sigmaConstant";
-import { SType } from "./base";
-import { descriptors } from "./descriptors";
-import { SCollType, STupleType } from "./generics";
-import { SUnitType } from "./monomorphics";
-import {
-  SBigIntType,
-  SBoolType,
-  SByteType,
-  SGroupElementType,
-  SIntType,
-  SLongType,
-  SShortType,
-  SSigmaPropType
-} from "./primitives";
-
-export type BigIntInput = string | bigint;
-export type ByteInput = Uint8Array | string;
-
-export type SConstructor<T = unknown, S extends SType = SType | SCollType<SType>> = (arg?: T) => S;
-
-type Constructable<T = any> = { new (...args: any): T };
-type GenericProxyArgs<R> = R extends (...args: any) => unknown ? Parameters<R> : [];
-
-type SProxy<T extends SType, I, O = I> = {
-  (value: I): SConstant<O, T>;
-  (value?: I): T;
-};
-
-/**
- * Creates a proxy for monomorphic types, this allows constructor
- * functions to be equivalent to their corresponding type.
- *
- * This function will return one instance of `ctor` if not params as set.
- * Otherwise it will return an `SigmaConstant` instance of `ctor` type.
- *
- * @example
- * // SInt is a proxy for SIntType
- * (intConstant instanceof SInt) === true
- * (intConstant instanceof SIntType) === true
- * @param ctor Class to be proxied.
- * @param cache If defined, proxy will return this instead of a new instance of `ctor`.
- * @param forceConstruction If true, bypasses the constant creation and returns a type.
- * @returns
- */
-function monoProxy<T extends SType, I, O = I>(
-  ctor: Constructable<T>,
-  cache?: T,
-  forceConstruction?: boolean
-): SProxy<T, I, O> {
-  return new Proxy(ctor, {
-    apply: (target, _, args) => {
-      const instance = cache ?? new target();
-      if (!forceConstruction && isEmpty(args)) return instance;
-
-      return new (SConstant as Constructable)(instance, ...args);
-    }
-  }) as any;
-}
-
-/**
- * Creates a proxy for generic types.
- */
-function genericProxy<T extends SType, R>(
-  ctor: Constructable<T>,
-  handler: (target: Constructable<T>, thisArgs: unknown, args: GenericProxyArgs<R>) => unknown
-) {
-  return new Proxy(ctor, {
-    apply: handler
-  }) as R;
-}
-
-export const SByte = monoProxy<SByteType, number>(SByteType, descriptors.byte);
-
-export const SBool = monoProxy<SBoolType, boolean>(SBoolType, descriptors.bool);
-
-export const SShort = monoProxy<SShortType, number>(SShortType, descriptors.short);
-
-export const SInt = monoProxy<SIntType, number>(SIntType, descriptors.int);
-
-export const SLong = monoProxy<SLongType, BigIntInput, bigint>(SLongType, descriptors.long);
-
-export const SBigInt = monoProxy<SBigIntType, BigIntInput, bigint>(SBigIntType, descriptors.bigInt);
-
-export const SGroupElement = monoProxy<SGroupElementType, ByteInput, Uint8Array>(
-  SGroupElementType,
-  descriptors.groupElement
-);
-
-export const SSigmaProp = monoProxy<SSigmaPropType, SConstant<Uint8Array>>(
-  SSigmaPropType,
-  descriptors.sigmaProp
-);
-
-type SUnit = (value?: undefined) => SConstant<undefined, SUnitType>;
-export const SUnit: SUnit = monoProxy(SUnitType, undefined, true);
-
-type SColl = {
-  <D, T extends SType>(type: SConstructor<D, T>): SConstructor<D[], T>;
-  <D, T extends SByteType>(
-    type: SConstructor<D, T>,
-    elements: ByteInput | D[]
-  ): SConstant<Uint8Array, T>;
-  <D, T extends SType>(type: SConstructor<D, T>, elements: D[]): SConstant<D[], T>;
-};
-
-export const SColl = genericProxy<SCollType, SColl>(SCollType, (target, _, args) => {
-  const [type, elements] = args;
-  const elementsType = type();
-  if (!elements) return () => new target(elementsType);
-
-  return new SConstant(new target(elementsType), elements);
-});
-
-export function STuple(...items: SConstant[]) {
-  return new SConstant(
-    new STupleType(items.map((x) => x.type)),
-    items.map((x) => x.data)
-  );
-}
-
-type ByteInputOr<D, T extends SType> = T extends SByteType ? ByteInput | D : D;
-type SPair = {
-  <L, R>(left: SConstant<L>, right: SConstant<R>): SConstant<[L, R], STupleType>;
-  <LD, RD, LT extends SType, RT extends SType>(
-    left: SConstructor<LD, LT>,
-    right: SConstructor<RD, RT>
-  ): SConstructor<[ByteInputOr<LD, LT>, ByteInputOr<RD, RT>]>;
-};
-
-export const SPair = genericProxy<STupleType, SPair>(STupleType, (target, _, args) => {
-  const [left, right] = args;
-
-  if (typeof left === "function" && typeof right === "function") {
-    return () => new target([left(), right()]);
-  } else if (left instanceof SConstant && right instanceof SConstant) {
-    return new SConstant(new target([left.type, right.type]), [left.data, right.data]);
-  }
-
-  throw new Error("Invalid tuple declaration.");
-});