@fleet-sdk/serializer 0.2.1 → 0.2.3

package/src/coders/sigmaReader.ts

@@ -1,81 +0,0 @@
-import { HexString, isEmpty } from "@fleet-sdk/common";
-import { hex } from "@fleet-sdk/crypto";
-import { hexToBigInt } from "./bigint";
-import { readBigVLQ, readVLQ } from "./vlq";
-import { zigZagDecode, zigZagDecodeBigInt } from "./zigZag";
-
-export class SigmaReader {
-  readonly #bytes: Uint8Array;
-  #cursor: number;
-
-  public get isEmpty(): boolean {
-    return isEmpty(this.#bytes);
-  }
-
-  constructor(bytes: HexString | Uint8Array) {
-    if (typeof bytes === "string") {
-      this.#bytes = hex.decode(bytes);
-    } else {
-      this.#bytes = bytes;
-    }
-
-    this.#cursor = 0;
-  }
-
-  public readBoolean(): boolean {
-    return this.readByte() === 0x01;
-  }
-
-  public readBits(length: number): ArrayLike<boolean> {
-    const bits = new Array<boolean>(length);
-    let bitOffset = 0;
-
-    for (let i = 0; i < length; i++) {
-      const bit = (this.#bytes[this.#cursor] >> bitOffset++) & 1;
-      bits[i] = bit === 1;
-
-      if (bitOffset == 8) {
-        bitOffset = 0;
-        this.#cursor++;
-      }
-    }
-
-    if (bitOffset > 0) {
-      this.#cursor++;
-    }
-
-    return bits;
-  }
-
-  public readByte(): number {
-    return this.#bytes[this.#cursor++];
-  }
-
-  public readBytes(length: number): Uint8Array {
-    return this.#bytes.subarray(this.#cursor, (this.#cursor += length));
-  }
-
-  public readVlq(): number {
-    return readVLQ(this);
-  }
-
-  public readShort(): number {
-    return Number(zigZagDecode(readVLQ(this)));
-  }
-
-  public readInt(): number {
-    const int = this.readLong();
-
-    return Number(int);
-  }
-
-  public readLong(): bigint {
-    return zigZagDecodeBigInt(readBigVLQ(this));
-  }
-
-  public readBigInt(): bigint {
-    const len = readVLQ(this);
-
-    return hexToBigInt(hex.encode(this.readBytes(len)));
-  }
-}

package/src/coders/sigmaWriter.ts

@@ -1,106 +0,0 @@
-import { hex } from "@fleet-sdk/crypto";
-import { bigIntToHex } from "./bigint";
-import { writeBigVLQ, writeVLQ } from "./vlq";
-import { zigZagEncode, zigZagEncodeBigInt } from "./zigZag";
-
-export class SigmaWriter {
-  readonly #bytes: Uint8Array;
-  #cursor: number;
-
-  public get length() {
-    return this.#cursor;
-  }
-
-  constructor(maxLength: number) {
-    this.#bytes = new Uint8Array(maxLength);
-    this.#cursor = 0;
-  }
-
-  public writeBoolean(value: boolean): SigmaWriter {
-    this.write(value === true ? 0x01 : 0x00);
-
-    return this;
-  }
-
-  public writeVLQ(value: number): SigmaWriter {
-    return writeVLQ(this, value);
-  }
-
-  public writeBigVLQ(value: bigint): SigmaWriter {
-    return writeBigVLQ(this, value);
-  }
-
-  public writeShort(value: number): SigmaWriter {
-    this.writeVLQ(zigZagEncode(value));
-
-    return this;
-  }
-
-  public writeInt(value: number): SigmaWriter {
-    this.writeLong(BigInt(value));
-
-    return this;
-  }
-
-  public writeLong(value: bigint): SigmaWriter {
-    this.writeBigVLQ(zigZagEncodeBigInt(value));
-
-    return this;
-  }
-
-  public write(byte: number): SigmaWriter {
-    this.#bytes[this.#cursor++] = byte;
-
-    return this;
-  }
-
-  public writeBytes(bytes: Uint8Array): SigmaWriter {
-    this.#bytes.set(bytes, this.#cursor);
-    this.#cursor += bytes.length;
-
-    return this;
-  }
-
-  public writeHex(bytesHex: string): SigmaWriter {
-    return this.writeBytes(hex.decode(bytesHex));
-  }
-
-  public writeBits(bits: ArrayLike<boolean>): SigmaWriter {
-    let bitOffset = 0;
-
-    for (let i = 0; i < bits.length; i++) {
-      if (bits[i]) {
-        this.#bytes[this.#cursor] |= 1 << bitOffset++;
-      } else {
-        this.#bytes[this.#cursor] &= ~(1 << bitOffset++);
-      }
-
-      if (bitOffset == 8) {
-        bitOffset = 0;
-        this.#cursor++;
-      }
-    }
-
-    if (bitOffset > 0) {
-      this.#cursor++;
-    }
-
-    return this;
-  }
-
-  public writeBigInt(value: bigint): SigmaWriter {
-    const hex = bigIntToHex(value);
-    this.writeVLQ(hex.length / 2);
-    this.writeHex(hex);
-
-    return this;
-  }
-
-  public toHex(): string {
-    return hex.encode(this.toBytes());
-  }
-
-  public toBytes(): Uint8Array {
-    return this.#bytes.subarray(0, this.#cursor);
-  }
-}

package/src/coders/vlq.ts

@@ -1,141 +0,0 @@
-import { _0n, _127n, _128n, _7n, ensureBigInt } from "@fleet-sdk/common";
-import { SigmaReader } from "./sigmaReader";
-import { SigmaWriter } from "./sigmaWriter";
-
-/**
- * A **variable-length quantity (VLQ)** is a universal code that uses an arbitrary number
- * of binary octets (eight-bit bytes) to represent an arbitrarily large integer. A VLQ
- * is essentially a base-128 representation of an unsigned integer with the addition of
- * the eighth bit to mark continuation of bytes. VLQ is identical to LEB128 except in
- * endianness. See the example below.
- */
-
-/**
- * Write an unsigned integer value as VLQ to a `SigmaWriter`.
- * @param value: Integer value
- * @param writer: Sigma writer
- * @returns Sigma writer passed as function argument.
- */
-export function writeVLQ(writer: SigmaWriter, value: number): SigmaWriter {
-  // source: https://stackoverflow.com/a/3564685
-
-  if (value === 0) {
-    return writer.write(0);
-  } else if (value < 0) {
-    throw new RangeError("Variable Length Quantity not supported for negative numbers.");
-  }
-
-  do {
-    let lower7bits = value & 0x7f;
-    value >>= 7;
-
-    if (value > 0) {
-      lower7bits |= 0x80;
-    }
-
-    writer.write(lower7bits);
-  } while (value > 0);
-
-  return writer;
-}
-
-/**
- * Decode VLQ bytes to an unsigned integer value
- * @param reader VLQ bytes
- * @returns Unsigned integer value
- */
-export function readVLQ(reader: SigmaReader): number {
-  if (reader.isEmpty) {
-    return 0;
-  }
-
-  let value = 0;
-  let shift = 0;
-  let lower7bits = 0;
-
-  do {
-    lower7bits = reader.readByte();
-    value |= (lower7bits & 0x7f) << shift;
-    shift += 7;
-  } while ((lower7bits & 0x80) != 0);
-
-  return value;
-}
-
-/**
- * Write an unsigned integer value as VLQ to a `SigmaWriter`.
- * @param value: Big integer value
- * @param writer: Sigma writer
- * @returns Sigma writer passed as function argument.
- */
-export function writeBigVLQ(writer: SigmaWriter, value: bigint): SigmaWriter {
-  // source: https://stackoverflow.com/a/3564685
-
-  if (value === _0n) {
-    return writer.write(0);
-  } else if (value < _0n) {
-    throw new RangeError("Variable Length Quantity not supported for negative numbers");
-  }
-
-  do {
-    let lower7bits = Number(value & _127n);
-    value >>= _7n;
-
-    if (value > 0) {
-      lower7bits |= 0x80;
-    }
-
-    writer.write(lower7bits);
-  } while (value > 0);
-
-  return writer;
-}
-
-/**
- * Decode VLQ bytes to an unsigned big integer value
- * @param reader VLQ bytes
- * @returns Unsigned integer value
- */
-export function readBigVLQ(reader: SigmaReader): bigint {
-  if (reader.isEmpty) {
-    return _0n;
-  }
-
-  let value = _0n;
-  let shift = _0n;
-  let lower7bits = _0n;
-
-  do {
-    lower7bits = BigInt(reader.readByte());
-    value |= (lower7bits & _127n) << shift;
-    shift += _7n;
-  } while ((lower7bits & _128n) != _0n);
-
-  return value;
-}
-
-/**
- * Estimates the byte size of a given unsigned integer.
- * @param value: the value to be evaluated.
- * @returns the byte size of the value.
- */
-export function estimateVLQSize(value: number | bigint | string): number {
-  let size = 0;
-
-  if (typeof value === "number") {
-    do {
-      size++;
-      value = Math.floor(value / 128);
-    } while (value > 0);
-
-    return size;
-  }
-
-  value = ensureBigInt(value);
-  do {
-    size++;
-    value /= _128n;
-  } while (value > _0n);
-
-  return size;
-}

package/src/coders/zigZag.ts

@@ -1,46 +0,0 @@
-import { _1n, _63n } from "@fleet-sdk/common";
-
-/**
- * ZigZag encoding maps signed integers to unsigned integers so that numbers
- * with a small absolute value (for instance, -1) have a small variant encoded
- * value too. It does this in a way that "zig-zags" back and forth through the
- * positive and negative integers, so that -1 is encoded as 1, 1 is encoded as 2,
- * -2 is encoded as 3, and so on.
- * @see https://developers.google.com/protocol-buffers/docs/encoding#types
- */
-
-/**
- * Encode a signed integer.
- * @param input Signed integer
- * @returns ZigZag-encoded value
- */
-export function zigZagEncode(input: number): number {
-  return (input << 1) ^ (input >> 63);
-}
-
-/**
- * Decode a ZigZag-encoded value.
- * @param input ZigZag-encoded value
- * @returns Signed integer
- */
-export function zigZagDecode(input: number): number {
-  return (input >> 1) ^ -(input & 1);
-}
-
-/**
- * Encode a signed big integer.
- * @param input Signed big integer
- * @returns ZigZag-encoded value
- */
-export function zigZagEncodeBigInt(input: bigint): bigint {
-  return (input << _1n) ^ (input >> _63n);
-}
-
-/**
- * Decode a ZigZag-encoded value.
- * @param input ZigZag-encoded value
- * @returns Signed big integer
- */
-export function zigZagDecodeBigInt(input: bigint): bigint {
-  return (input >> _1n) ^ -(input & _1n);
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export { estimateVLQSize } from "./coders";
-export { SConstant, parse } from "./sigmaConstant";
-export * from "./types";
-export * from "./serializers";

package/src/serializers/boxSerializer.ts

@@ -1,139 +0,0 @@
-import {
-  Amount,
-  Box,
-  BoxCandidate,
-  byteSizeOf,
-  ensureBigInt,
-  isDefined,
-  isEmpty,
-  isUndefined,
-  NonMandatoryRegisters,
-  some,
-  TokenAmount
-} from "@fleet-sdk/common";
-import { estimateVLQSize, SigmaWriter } from "../coders";
-
-const MAX_UINT16_VALUE = 65535;
-
-export function serializeBox(box: Box<Amount>): SigmaWriter;
-export function serializeBox(box: Box<Amount>, writer: SigmaWriter): SigmaWriter;
-export function serializeBox(
-  box: BoxCandidate<Amount>,
-  writer: SigmaWriter,
-  distinctTokenIds: string[]
-): SigmaWriter;
-export function serializeBox(
-  box: Box<Amount> | BoxCandidate<Amount>,
-  writer?: SigmaWriter,
-  distinctTokenIds?: string[]
-): SigmaWriter {
-  if (!writer) {
-    writer = new SigmaWriter(5_0000);
-  }
-
-  writer.writeBigVLQ(ensureBigInt(box.value));
-  writer.writeHex(box.ergoTree);
-  writer.writeVLQ(box.creationHeight);
-  writeTokens(writer, box.assets, distinctTokenIds);
-  writeRegisters(writer, box.additionalRegisters);
-
-  if (isDefined(distinctTokenIds)) {
-    return writer;
-  } else {
-    if (!isBox(box)) {
-      throw new Error("Invalid box type.");
-    }
-
-    return writer.writeHex(box.transactionId).writeVLQ(box.index);
-  }
-}
-
-function isBox<T extends Amount>(box: Box<Amount> | BoxCandidate<Amount>): box is Box<T> {
-  const castedBox = box as Box<T>;
-
-  return isDefined(castedBox.transactionId) && isDefined(castedBox.index);
-}
-
-function writeTokens(
-  writer: SigmaWriter,
-  tokens: TokenAmount<Amount>[],
-  tokenIds?: string[]
-): void {
-  if (isEmpty(tokens)) {
-    writer.write(0);
-
-    return;
-  }
-
-  writer.writeVLQ(tokens.length);
-  if (some(tokenIds)) {
-    tokens.map((token) =>
-      writer.writeVLQ(tokenIds.indexOf(token.tokenId)).writeBigVLQ(ensureBigInt(token.amount))
-    );
-  } else {
-    tokens.map((token) => writer.writeHex(token.tokenId).writeBigVLQ(ensureBigInt(token.amount)));
-  }
-}
-
-function writeRegisters(writer: SigmaWriter, registers: NonMandatoryRegisters): void {
-  const keys = Object.keys(registers).sort();
-  let length = 0;
-
-  for (const key of keys) {
-    if (registers[key as keyof NonMandatoryRegisters]) {
-      length++;
-    }
-  }
-
-  writer.writeVLQ(length);
-  if (length == 0) {
-    return;
-  }
-
-  for (const key of keys) {
-    const register = registers[key as keyof NonMandatoryRegisters];
-    if (isDefined(register)) {
-      writer.writeHex(register);
-    }
-  }
-}
-
-/**
- * Estimates the byte size a box.
- * @returns byte size of the box.
- */
-export function estimateBoxSize(
-  box: Box<Amount> | BoxCandidate<Amount>,
-  withValue?: Amount
-): number {
-  if (isUndefined(box.creationHeight)) {
-    throw new Error("Box size estimation error: creation height is undefined.");
-  }
-
-  let size = 0;
-
-  size += estimateVLQSize(isDefined(withValue) ? withValue : box.value);
-  size += byteSizeOf(box.ergoTree);
-  size += estimateVLQSize(box.creationHeight);
-
-  size += estimateVLQSize(box.assets.length);
-  size += box.assets.reduce(
-    (acc: number, curr) => (acc += byteSizeOf(curr.tokenId) + estimateVLQSize(curr.amount)),
-    0
-  );
-
-  let registersLength = 0;
-  for (const key in box.additionalRegisters) {
-    const register = box.additionalRegisters[key as keyof NonMandatoryRegisters];
-    if (register) {
-      size += byteSizeOf(register);
-      registersLength++;
-    }
-  }
-  size += estimateVLQSize(registersLength);
-
-  size += 32; // transaction id (BLAKE2b 256 hash)
-  size += estimateVLQSize(isBox(box) ? box.index : MAX_UINT16_VALUE);
-
-  return size;
-}

package/src/serializers/dataSerializer.ts

@@ -1,141 +0,0 @@
-import { assert } from "@fleet-sdk/common";
-import { SigmaReader, SigmaWriter } from "../coders";
-import { SConstant } from "../sigmaConstant";
-import { isColl, isTuple, SCollType, STupleType, SType } from "../types";
-import { descriptors } from "../types/descriptors";
-
-const GROUP_ELEMENT_LENGTH = 33;
-const PROVE_DLOG_OP = 0xcd;
-
-export class DataSerializer {
-  public static serialize(data: unknown, type: SType, writer: SigmaWriter): SigmaWriter {
-    if (type.embeddable) {
-      switch (type.code) {
-        case descriptors.bool.code:
-          return writer.writeBoolean(data as boolean);
-        case descriptors.byte.code:
-          return writer.write(data as number);
-        case descriptors.short.code:
-          return writer.writeShort(data as number);
-        case descriptors.int.code:
-          return writer.writeInt(data as number);
-        case descriptors.long.code:
-          return writer.writeLong(data as bigint);
-        case descriptors.bigInt.code: {
-          return writer.writeBigInt(data as bigint);
-        }
-        case descriptors.groupElement.code:
-          return writer.writeBytes(data as Uint8Array);
-        case descriptors.sigmaProp.code: {
-          const node = data as SConstant<SConstant<Uint8Array>>;
-
-          if (node.type === descriptors.groupElement) {
-            writer.write(PROVE_DLOG_OP);
-
-            return DataSerializer.serialize(node.data, node.type, writer);
-          } else {
-            throw Error("Serialization error: SigmaProp operation not implemented.");
-          }
-        }
-      }
-    } else if (isColl(type)) {
-      if (type.elementsType.code === descriptors.byte.code) {
-        const isUint8Array = data instanceof Uint8Array;
-        assert(isUint8Array, `SColl[Byte] expected an UInt8Array, got ${typeof data}.`);
-      } else {
-        assert(Array.isArray(data), `SColl expected an array, got ${typeof data}.`);
-      }
-
-      writer.writeVLQ(data.length);
-      switch (type.elementsType.code) {
-        case descriptors.bool.code: {
-          return writer.writeBits(data as boolean[]);
-        }
-        case descriptors.byte.code: {
-          return writer.writeBytes(data as Uint8Array);
-        }
-        default: {
-          for (let i = 0; i < data.length; i++) {
-            DataSerializer.serialize(data[i], type.elementsType, writer);
-          }
-
-          return writer;
-        }
-      }
-    } else if (isTuple(type)) {
-      assert(
-        Array.isArray(data),
-        `STupleType serialization expected an array, got ${typeof data}.`
-      );
-
-      const len = type.elementsType.length;
-      for (let i = 0; i < len; i++) {
-        DataSerializer.serialize(data[i], type.elementsType[i], writer);
-      }
-
-      return writer;
-    } else if (type.code === descriptors.unit.code) {
-      return writer;
-    }
-
-    throw Error(`Serialization error: '0x${type.code.toString(16)}' type not implemented.`);
-  }
-
-  static deserialize(type: SType, reader: SigmaReader): unknown {
-    if (type.embeddable) {
-      switch (type.code) {
-        case descriptors.bool.code:
-          return reader.readBoolean();
-        case descriptors.byte.code:
-          return reader.readByte();
-        case descriptors.short.code:
-          return reader.readShort();
-        case descriptors.int.code:
-          return reader.readInt();
-        case descriptors.long.code:
-          return reader.readLong();
-        case descriptors.bigInt.code:
-          return reader.readBigInt();
-        case descriptors.groupElement.code:
-          return reader.readBytes(GROUP_ELEMENT_LENGTH);
-        case descriptors.sigmaProp.code: {
-          if (reader.readByte() === PROVE_DLOG_OP) {
-            return this.deserialize(descriptors.groupElement, reader);
-          }
-
-          break;
-        }
-      }
-    } else {
-      switch (type.code) {
-        case descriptors.coll.code: {
-          const length = reader.readVlq();
-          const embeddedType = (type as SCollType).elementsType;
-
-          switch (embeddedType.code) {
-            case descriptors.bool.code:
-              return reader.readBits(length);
-            case descriptors.byte.code:
-              return reader.readBytes(length);
-            default: {
-              const elements = new Array(length);
-              for (let i = 0; i < length; i++) {
-                elements[i] = this.deserialize(embeddedType, reader);
-              }
-
-              return elements;
-            }
-          }
-        }
-        case descriptors.tuple.code: {
-          return (type as STupleType).elementsType.map((t) => this.deserialize(t, reader));
-        }
-        case descriptors.unit.code: {
-          return undefined;
-        }
-      }
-    }
-
-    throw new Error(`Parsing error: '0x${type.code.toString(16)}' type not implemented.`);
-  }
-}

package/src/serializers/index.ts

@@ -1,4 +0,0 @@
-export * from "./boxSerializer";
-export * from "./transactionSerializer";
-export * from "./dataSerializer";
-export * from "./typeSerializer";