@fleet-sdk/serializer 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# @fleet-sdk/serializer
+
+## 0.2.0
+
+### Minor Changes
+
+- 76d4c3d: Introduce `serializer` package.
+- cd877ce: Add embedded `SColl` support.
+- cd877ce: Add `SPair` type support.
+- e532fb8: Add type string representation.
+
+### Patch Changes
+
+- Updated dependencies [5a79c57]
+- Updated dependencies [8a13a29]
+- Updated dependencies [a491ab9]
+- Updated dependencies [3236dd8]
+- Updated dependencies [9bd393b]
+- Updated dependencies [2ab9661]
+- Updated dependencies [2ab9661]
+  - @fleet-sdk/common@0.2.0
+  - @fleet-sdk/crypto@0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Nautilus Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @fleet-sdk/serializer [![License](https://badgen.net/github/license/fleet-sdk/fleet/)](https://github.com/fleet-sdk/fleet/blob/master/LICENSE) [![npm](https://badgen.net/npm/v/@fleet-sdk/serializer)](https://www.npmjs.com/package/@fleet-sdk/serializer)
+
+Ergo constant serializer and parser.

package/dist/index.d.mts

@@ -0,0 +1,191 @@
+import { BytesInput } from '@fleet-sdk/crypto';
+import { HexString, Box, Amount, BoxCandidate, UnsignedInput, DataInput } from '@fleet-sdk/common';
+
+declare class SigmaReader {
+    #private;
+    get isEmpty(): boolean;
+    constructor(bytes: HexString | Uint8Array);
+    readBoolean(): boolean;
+    readBits(length: number): ArrayLike<boolean>;
+    readByte(): number;
+    readBytes(length: number): Uint8Array;
+    readVlq(): number;
+    readShort(): number;
+    readInt(): number;
+    readLong(): bigint;
+    readBigInt(): bigint;
+}
+
+declare class SigmaWriter {
+    #private;
+    get length(): number;
+    constructor(maxLength: number);
+    writeBoolean(value: boolean): SigmaWriter;
+    writeVLQ(value: number): SigmaWriter;
+    writeBigVLQ(value: bigint): SigmaWriter;
+    writeShort(value: number): SigmaWriter;
+    writeInt(value: number): SigmaWriter;
+    writeLong(value: bigint): SigmaWriter;
+    write(byte: number): SigmaWriter;
+    writeBytes(bytes: Uint8Array): SigmaWriter;
+    writeHex(bytesHex: string): SigmaWriter;
+    writeBits(bits: ArrayLike<boolean>): SigmaWriter;
+    writeBigInt(value: bigint): SigmaWriter;
+    toHex(): string;
+    toBytes(): Uint8Array;
+}
+
+/**
+ * Estimates the byte size of a given unsigned integer.
+ * @param value: the value to be evaluated.
+ * @returns the byte size of the value.
+ */
+declare function estimateVLQSize(value: number | bigint | string): number;
+
+declare abstract class SType<I = unknown, O = I> {
+    abstract get code(): number;
+    abstract get embeddable(): boolean;
+    coerce(data: I): O;
+    abstract toString(): string;
+}
+declare abstract class SMonomorphicType<I, O = I> extends SType<I, O> {
+    abstract get code(): number;
+    get embeddable(): boolean;
+}
+declare abstract class SPrimitiveType<I, O = I> extends SMonomorphicType<I, O> {
+    abstract get code(): number;
+    get embeddable(): boolean;
+}
+declare abstract class SGenericType<T extends SType | SType[]> extends SType {
+    #private;
+    constructor(type: T);
+    abstract get code(): number;
+    get elementsType(): T;
+    get embeddable(): boolean;
+}
+
+declare class SCollType<T extends SType = SType> extends SGenericType<T> {
+    get code(): number;
+    coerce<I, O>(elements: I[]): O[] | Uint8Array;
+    toString(): string;
+}
+declare class STupleType<T extends SType[] = SType[]> extends SGenericType<T> {
+    get code(): number;
+    coerce<I, O>(elements: I[]): O[];
+    toString(): string;
+}
+
+declare class SUnitType extends SMonomorphicType<undefined> {
+    get code(): 0x62;
+    toString(): string;
+}
+
+type BigIntInput = string | bigint;
+type ByteInput = Uint8Array | string;
+type SConstructor<T = unknown, S extends SType = SType | SCollType<SType>> = (arg?: T) => S;
+type SProxy<T extends SType, I, O = I> = {
+    (value: I): SConstant<O, T>;
+    (value?: I): T;
+};
+declare const SByte: SProxy<SByteType, number, number>;
+declare const SBool: SProxy<SBoolType, boolean, boolean>;
+declare const SShort: SProxy<SShortType, number, number>;
+declare const SInt: SProxy<SIntType, number, number>;
+declare const SLong: SProxy<SLongType, BigIntInput, bigint>;
+declare const SBigInt: SProxy<SBigIntType, BigIntInput, bigint>;
+declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array>;
+declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array, SType<unknown, unknown>>, SConstant<Uint8Array, SType<unknown, unknown>>>;
+type SUnit = (value?: undefined) => SConstant<undefined, SUnitType>;
+declare const SUnit: SUnit;
+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>;
+};
+declare const SColl: SColl;
+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>]>;
+};
+declare const SPair: SPair;
+
+declare class SBoolType extends SPrimitiveType<boolean> {
+    get code(): 0x01;
+    toString(): string;
+}
+declare class SByteType extends SPrimitiveType<number> {
+    get code(): 0x02;
+    toString(): string;
+}
+declare class SShortType extends SPrimitiveType<number> {
+    get code(): 0x03;
+    toString(): string;
+}
+declare class SIntType extends SPrimitiveType<number> {
+    get code(): 0x04;
+    toString(): string;
+}
+declare class SLongType extends SPrimitiveType<BigIntInput, bigint> {
+    get code(): 0x05;
+    coerce(data: BigIntInput): bigint;
+    toString(): string;
+}
+declare class SBigIntType extends SPrimitiveType<string | bigint, bigint> {
+    get code(): number;
+    coerce(data: BigIntInput): bigint;
+    toString(): string;
+}
+declare class SGroupElementType extends SPrimitiveType<ByteInput, Uint8Array> {
+    get code(): 0x07;
+    coerce(data: ByteInput): Uint8Array;
+    toString(): string;
+}
+declare class SSigmaPropType extends SPrimitiveType<SConstant<Uint8Array>> {
+    get code(): 0x08;
+    toString(): string;
+}
+
+declare function isColl(type: SType): type is SCollType;
+declare function isTuple(type: SType): type is STupleType;
+
+declare class SConstant<D = unknown, T extends SType = SType> {
+    #private;
+    constructor(type: T, data: D);
+    static from<D, T extends SType = SType>(bytes: BytesInput): SConstant<D, T>;
+    get type(): T;
+    get data(): D;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare function parse<T>(bytes: BytesInput): T;
+declare function parse<T>(bytes: BytesInput, mode: "strict"): T;
+declare function parse<T>(bytes: BytesInput, mode: "safe"): T | undefined;
+
+declare function serializeBox(box: Box<Amount>): SigmaWriter;
+declare function serializeBox(box: Box<Amount>, writer: SigmaWriter): SigmaWriter;
+declare function serializeBox(box: BoxCandidate<Amount>, writer: SigmaWriter, distinctTokenIds: string[]): SigmaWriter;
+/**
+ * Estimates the byte size a box.
+ * @returns byte size of the box.
+ */
+declare function estimateBoxSize(box: Box<Amount> | BoxCandidate<Amount>, withValue?: Amount): number;
+
+type MinimalUnsignedTransaction = {
+    inputs: readonly UnsignedInput[];
+    dataInputs: readonly DataInput[];
+    outputs: readonly BoxCandidate<Amount>[];
+};
+declare function serializeTransaction(transaction: MinimalUnsignedTransaction): SigmaWriter;
+
+declare class DataSerializer {
+    static serialize(data: unknown, type: SType, writer: SigmaWriter): SigmaWriter;
+    static deserialize(type: SType, reader: SigmaReader): unknown;
+}
+
+declare class TypeSerializer {
+    static serialize(type: SType, writer: SigmaWriter): void;
+    static deserialize(r: SigmaReader): SType;
+}
+
+export { DataSerializer, MinimalUnsignedTransaction, SBigInt, SBigIntType, SBool, SBoolType, SByte, SByteType, SColl, SCollType, SConstant, SGenericType, SGroupElement, SGroupElementType, SInt, SIntType, SLong, SLongType, SMonomorphicType, SPair, SPrimitiveType, SShort, SShortType, SSigmaProp, SSigmaPropType, STupleType, SType, SUnit, SUnitType, TypeSerializer, estimateBoxSize, estimateVLQSize, isColl, isTuple, parse, serializeBox, serializeTransaction };

package/dist/index.d.ts

@@ -0,0 +1,191 @@
+import { BytesInput } from '@fleet-sdk/crypto';
+import { HexString, Box, Amount, BoxCandidate, UnsignedInput, DataInput } from '@fleet-sdk/common';
+
+declare class SigmaReader {
+    #private;
+    get isEmpty(): boolean;
+    constructor(bytes: HexString | Uint8Array);
+    readBoolean(): boolean;
+    readBits(length: number): ArrayLike<boolean>;
+    readByte(): number;
+    readBytes(length: number): Uint8Array;
+    readVlq(): number;
+    readShort(): number;
+    readInt(): number;
+    readLong(): bigint;
+    readBigInt(): bigint;
+}
+
+declare class SigmaWriter {
+    #private;
+    get length(): number;
+    constructor(maxLength: number);
+    writeBoolean(value: boolean): SigmaWriter;
+    writeVLQ(value: number): SigmaWriter;
+    writeBigVLQ(value: bigint): SigmaWriter;
+    writeShort(value: number): SigmaWriter;
+    writeInt(value: number): SigmaWriter;
+    writeLong(value: bigint): SigmaWriter;
+    write(byte: number): SigmaWriter;
+    writeBytes(bytes: Uint8Array): SigmaWriter;
+    writeHex(bytesHex: string): SigmaWriter;
+    writeBits(bits: ArrayLike<boolean>): SigmaWriter;
+    writeBigInt(value: bigint): SigmaWriter;
+    toHex(): string;
+    toBytes(): Uint8Array;
+}
+
+/**
+ * Estimates the byte size of a given unsigned integer.
+ * @param value: the value to be evaluated.
+ * @returns the byte size of the value.
+ */
+declare function estimateVLQSize(value: number | bigint | string): number;
+
+declare abstract class SType<I = unknown, O = I> {
+    abstract get code(): number;
+    abstract get embeddable(): boolean;
+    coerce(data: I): O;
+    abstract toString(): string;
+}
+declare abstract class SMonomorphicType<I, O = I> extends SType<I, O> {
+    abstract get code(): number;
+    get embeddable(): boolean;
+}
+declare abstract class SPrimitiveType<I, O = I> extends SMonomorphicType<I, O> {
+    abstract get code(): number;
+    get embeddable(): boolean;
+}
+declare abstract class SGenericType<T extends SType | SType[]> extends SType {
+    #private;
+    constructor(type: T);
+    abstract get code(): number;
+    get elementsType(): T;
+    get embeddable(): boolean;
+}
+
+declare class SCollType<T extends SType = SType> extends SGenericType<T> {
+    get code(): number;
+    coerce<I, O>(elements: I[]): O[] | Uint8Array;
+    toString(): string;
+}
+declare class STupleType<T extends SType[] = SType[]> extends SGenericType<T> {
+    get code(): number;
+    coerce<I, O>(elements: I[]): O[];
+    toString(): string;
+}
+
+declare class SUnitType extends SMonomorphicType<undefined> {
+    get code(): 0x62;
+    toString(): string;
+}
+
+type BigIntInput = string | bigint;
+type ByteInput = Uint8Array | string;
+type SConstructor<T = unknown, S extends SType = SType | SCollType<SType>> = (arg?: T) => S;
+type SProxy<T extends SType, I, O = I> = {
+    (value: I): SConstant<O, T>;
+    (value?: I): T;
+};
+declare const SByte: SProxy<SByteType, number, number>;
+declare const SBool: SProxy<SBoolType, boolean, boolean>;
+declare const SShort: SProxy<SShortType, number, number>;
+declare const SInt: SProxy<SIntType, number, number>;
+declare const SLong: SProxy<SLongType, BigIntInput, bigint>;
+declare const SBigInt: SProxy<SBigIntType, BigIntInput, bigint>;
+declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array>;
+declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array, SType<unknown, unknown>>, SConstant<Uint8Array, SType<unknown, unknown>>>;
+type SUnit = (value?: undefined) => SConstant<undefined, SUnitType>;
+declare const SUnit: SUnit;
+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>;
+};
+declare const SColl: SColl;
+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>]>;
+};
+declare const SPair: SPair;
+
+declare class SBoolType extends SPrimitiveType<boolean> {
+    get code(): 0x01;
+    toString(): string;
+}
+declare class SByteType extends SPrimitiveType<number> {
+    get code(): 0x02;
+    toString(): string;
+}
+declare class SShortType extends SPrimitiveType<number> {
+    get code(): 0x03;
+    toString(): string;
+}
+declare class SIntType extends SPrimitiveType<number> {
+    get code(): 0x04;
+    toString(): string;
+}
+declare class SLongType extends SPrimitiveType<BigIntInput, bigint> {
+    get code(): 0x05;
+    coerce(data: BigIntInput): bigint;
+    toString(): string;
+}
+declare class SBigIntType extends SPrimitiveType<string | bigint, bigint> {
+    get code(): number;
+    coerce(data: BigIntInput): bigint;
+    toString(): string;
+}
+declare class SGroupElementType extends SPrimitiveType<ByteInput, Uint8Array> {
+    get code(): 0x07;
+    coerce(data: ByteInput): Uint8Array;
+    toString(): string;
+}
+declare class SSigmaPropType extends SPrimitiveType<SConstant<Uint8Array>> {
+    get code(): 0x08;
+    toString(): string;
+}
+
+declare function isColl(type: SType): type is SCollType;
+declare function isTuple(type: SType): type is STupleType;
+
+declare class SConstant<D = unknown, T extends SType = SType> {
+    #private;
+    constructor(type: T, data: D);
+    static from<D, T extends SType = SType>(bytes: BytesInput): SConstant<D, T>;
+    get type(): T;
+    get data(): D;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare function parse<T>(bytes: BytesInput): T;
+declare function parse<T>(bytes: BytesInput, mode: "strict"): T;
+declare function parse<T>(bytes: BytesInput, mode: "safe"): T | undefined;
+
+declare function serializeBox(box: Box<Amount>): SigmaWriter;
+declare function serializeBox(box: Box<Amount>, writer: SigmaWriter): SigmaWriter;
+declare function serializeBox(box: BoxCandidate<Amount>, writer: SigmaWriter, distinctTokenIds: string[]): SigmaWriter;
+/**
+ * Estimates the byte size a box.
+ * @returns byte size of the box.
+ */
+declare function estimateBoxSize(box: Box<Amount> | BoxCandidate<Amount>, withValue?: Amount): number;
+
+type MinimalUnsignedTransaction = {
+    inputs: readonly UnsignedInput[];
+    dataInputs: readonly DataInput[];
+    outputs: readonly BoxCandidate<Amount>[];
+};
+declare function serializeTransaction(transaction: MinimalUnsignedTransaction): SigmaWriter;
+
+declare class DataSerializer {
+    static serialize(data: unknown, type: SType, writer: SigmaWriter): SigmaWriter;
+    static deserialize(type: SType, reader: SigmaReader): unknown;
+}
+
+declare class TypeSerializer {
+    static serialize(type: SType, writer: SigmaWriter): void;
+    static deserialize(r: SigmaReader): SType;
+}
+
+export { DataSerializer, MinimalUnsignedTransaction, SBigInt, SBigIntType, SBool, SBoolType, SByte, SByteType, SColl, SCollType, SConstant, SGenericType, SGroupElement, SGroupElementType, SInt, SIntType, SLong, SLongType, SMonomorphicType, SPair, SPrimitiveType, SShort, SShortType, SSigmaProp, SSigmaPropType, STupleType, SType, SUnit, SUnitType, TypeSerializer, estimateBoxSize, estimateVLQSize, isColl, isTuple, parse, serializeBox, serializeTransaction };