phantasma-sdk-ts 0.1.76 → 0.2.0-rc.0

package/src/core/types/Entropy.ts

@@ -1,16 +0,0 @@
-import crypto from "crypto";
-export class Entropy {
-  //private static rnd = crypto.randomBytes(24);
-  public static GetRandomBytes(targetLength: number): Buffer {
-    let rnd = new Uint8Array(targetLength);
-    const privateKey = Buffer.alloc(rnd.byteLength);
-
-    crypto.getRandomValues(rnd);
-
-    for (let i = 0; i < 32; ++i) {
-      privateKey.writeUInt8(rnd[i], i);
-    }
-    //let pk = this.ToBuffer(rnd);
-    return privateKey;
-  }
-}

package/src/core/types/Extensions/Base16.ts

@@ -1,36 +0,0 @@
-import { hexStringToUint8Array, stringToUint8Array } from "../../utils";
-
-export class Base16 {
-  static encode(str: string) {
-    if (!str) return "";
-
-    return str
-      .split("")
-      .map((c) => c.charCodeAt(0).toString(16).padStart(2, "0"))
-      .join("");
-  }
-
-  static encodeUint8Array(arr: Uint8Array) {
-    return Array.from(arr)
-      .map((c) => c.toString(16).padStart(2, "0"))
-      .join("")
-      .toUpperCase();
-  }
-
-  static decode(str: string) {
-    if (!str || str.length % 2 !== 0) return "";
-
-    return (
-      str
-        .match(/.{1,2}/g)
-        ?.map((c) => String.fromCharCode(parseInt(c, 16)))
-        .join("") ?? ""
-    );
-  }
-
-  static decodeUint8Array(str: string): Uint8Array {
-    if (!str || str.length % 2 !== 0) return new Uint8Array(0);
-
-    return new Uint8Array(stringToUint8Array(this.decode(str)));
-  }
-}

package/src/core/types/Extensions/Describer.ts

@@ -1,17 +0,0 @@
-export class Describer {
-  private static FRegEx = new RegExp(/(?:this\.)(.+?(?= ))/g);
-  static describe(val: Function, parent = false): string[] {
-    var result = [];
-    if (parent) {
-      var proto = Object.getPrototypeOf(val.prototype);
-      if (proto) {
-        result = result.concat(this.describe(proto.constructor, parent));
-      }
-    }
-    result = result.concat(val.toString().match(this.FRegEx) || []);
-    /*.filter((x) => {
-        x.replace("this.", "");
-      })*/
-    return result;
-  }
-}

package/src/core/types/Extensions/PBinaryReader.ts

@@ -1,247 +0,0 @@
-import BigInteger from "big-integer";
-import { BinaryWriter, BinaryReader, Encoding } from "csharp-binary-stream";
-import { ISignature, SignatureKind, Signature } from "../../interfaces";
-import { byteArrayToHex, stringToUint8Array } from "../../utils";
-import { VMType } from "../../vm";
-import { Ed25519Signature } from "../Ed25519Signature";
-import { Timestamp } from "../Timestamp";
-
-export class PBinaryReader {
-  reader: BinaryReader;
-  get length(): number {
-    return this.reader.length;
-  }
-  get position(): number {
-    return this.reader.position;
-  }
-  set position(value: number) {
-    this.reader.position = value;
-  }
-  get isEndOfStream(): boolean {
-    return this.reader.isEndOfStream;
-  }
-  readBoolean(): boolean {
-    return this.reader.readBoolean();
-  }
-  readByte(): number {
-    return this.reader.readByte();
-  }
-  readBytes(bytesToRead: number): number[] {
-    return this.reader.readBytes(bytesToRead);
-  }
-  readSignedByte(): number {
-    return this.reader.readSignedByte();
-  }
-  readShort(): number {
-    return this.reader.readShort();
-  }
-  readUnsignedShort(): number {
-    return this.reader.readUnsignedShort();
-  }
-  readInt(): number {
-    return this.reader.readInt();
-  }
-  readUnsignedInt(): number {
-    return this.reader.readUnsignedInt();
-  }
-  readLongString(): string {
-    return this.reader.readLongString();
-  }
-  readLong(): number {
-    return this.reader.readLong();
-  }
-  readUnsignedLongString(): string {
-    return this.reader.readUnsignedLongString();
-  }
-  readUnsignedLong(): number {
-    return this.reader.readUnsignedLong();
-  }
-  readFloat(): number {
-    return this.reader.readFloat();
-  }
-  readDouble(): number {
-    return this.reader.readDouble();
-  }
-  readChar(encoding: Encoding): string {
-    return this.reader.readChar(encoding);
-  }
-  readChars(charactersToRead: number, encoding: Encoding): string {
-    return this.reader.readChars(charactersToRead, encoding);
-  }
-  readCharBytes(bytesToRead: number, encoding: Encoding): string {
-    return this.reader.readCharBytes(bytesToRead, encoding);
-  }
-
-  constructor(arg1: Buffer | Uint8Array) {
-    this.reader = new BinaryReader(arg1);
-  }
-
-  public read(numBytes: number): string {
-    var res = byteArrayToHex(this.readBytes(numBytes)).substr(0, numBytes * 2);
-    //this.position += numBytes;
-    return res;
-  }
-
-  public readString(): string {
-    var len = this.readVarInt();
-    return this.readStringBytes(len);
-  }
-
-  public readStringBytes(numBytes: number) {
-    var res = "";
-    for (var i = 0; i < numBytes; ++i) {
-      res += String.fromCharCode(this.readByte());
-    }
-    return res;
-  }
-
-  public readBigInteger(): BigInt {
-    // TO DO: implement negative numbers
-    var len = this.readVarInt();
-    var res = 0;
-    var stringBytes = this.read(len);
-    [...(stringBytes.match(/.{1,2}/g) as any)]
-      .reverse()
-      .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-
-    let bigInt = BigInt(res);
-    return bigInt;
-  }
-
-  public readBigIntAccurate() {
-    var len = this.readVarInt();
-    var res = BigInteger();
-    var stringBytes = this.read(len);
-    [...(stringBytes.match(/.{1,2}/g) as any)].reverse().forEach((c) => {
-      res = res.times(256).plus(parseInt(c, 16));
-    });
-    return res.toString();
-  }
-
-  public readSignatureV2(): Signature {
-    let kind = this.readByte() as SignatureKind;
-    let curve;
-    let signature: Signature = new Ed25519Signature();
-
-    switch (kind) {
-      case SignatureKind.None:
-        return null;
-
-      case SignatureKind.Ed25519:
-        let len = this.readVarInt();
-        signature.Bytes = stringToUint8Array(this.read(len));
-        break;
-      case SignatureKind.ECDSA:
-        curve = this.readByte();
-        signature.Bytes = stringToUint8Array(this.readString());
-        break;
-      default:
-        throw "read signature: " + kind;
-    }
-
-    return signature;
-  }
-
-  public readSignature(): Signature {
-    let kind = this.readByte() as SignatureKind;
-    let signature: Signature = new Ed25519Signature();
-    let curve;
-    signature.Kind = kind;
-    switch (kind) {
-      case SignatureKind.None:
-        return null;
-
-      case SignatureKind.Ed25519:
-        let len = this.readVarInt();
-        signature.Bytes = stringToUint8Array(this.read(len));
-        break;
-      case SignatureKind.ECDSA:
-        curve = this.readByte();
-        signature.Bytes = stringToUint8Array(this.readString());
-        break;
-      default:
-        throw "read signature: " + kind;
-    }
-
-    return signature;
-  }
-
-  public readByteArray() {
-    var res;
-    var length = this.readVarInt();
-    if (length == 0) return [];
-
-    res = this.read(length);
-    return res;
-  }
-
-  public readTimestamp(): Timestamp {
-    //var len = this.readByte();
-    let result = 0;
-    let bytes = this.read(4);
-    //[...(bytes.match(/.{1,2}/g) as any)];
-    bytes
-      .match(/.{1,2}/g)
-      .reverse()
-      .forEach((c) => (result = result * 256 + parseInt(c, 16)));
-
-    let timestamp = new Timestamp(result);
-    return timestamp;
-  }
-
-  public readVarInt(): number {
-    var len = this.readByte();
-    var res = 0;
-    if (len === 0xfd) {
-      [...(this.read(2).match(/.{1,2}/g) as any)]
-        .reverse()
-        .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-      return res;
-    } else if (len === 0xfe) {
-      [...(this.read(4).match(/.{1,2}/g) as any)]
-        .reverse()
-        .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-      return res;
-    } else if (len === 0xff) {
-      [...(this.read(8).match(/.{1,2}/g) as any)]
-        .reverse()
-        .forEach((c) => (res = res * 256 + parseInt(c, 16)));
-      return res;
-    }
-    return len;
-  }
-
-  public readVarString(): string {
-    var len = this.readVarInt();
-    if (len == 0) return "";
-    return this.readStringBytes(len);
-  }
-
-  public readVmObject() {
-    const type = this.readByte();
-    switch (type) {
-      case VMType.String:
-        return this.readString();
-      case VMType.Number:
-        return this.readBigIntAccurate();
-      case VMType.Bool:
-        return this.readByte() != 0;
-      case VMType.Struct:
-        const numFields = this.readVarInt();
-        let res = {};
-        for (let i = 0; i < numFields; ++i) {
-          const key: any = this.readVmObject();
-          const value = this.readVmObject();
-          res[key] = value;
-        }
-        return res;
-      case VMType.Enum:
-        return this.readVarInt();
-      case VMType.Object:
-        const numBytes = this.readVarInt();
-        return this.read(numBytes);
-      default:
-        return "unsupported type " + type;
-    }
-  }
-}

package/src/core/types/Extensions/PBinaryWriter.ts

@@ -1,278 +0,0 @@
-//import { BinaryWriter, BinaryReader, Encoding } from "csharp-binary-stream";
-import bigInt from "big-integer";
-import { BinaryWriter, Encoding } from "csharp-binary-stream";
-import {
-  hexStringToBytes,
-  hexStringToUint8Array,
-  hexToByteArray,
-  stringToUint8Array,
-} from "../..";
-import { ISignature, Signature, SignatureKind } from "../../interfaces";
-import { Timestamp } from "../Timestamp";
-
-type byte = number;
-
-export class PBinaryWriter {
-  private writer: BinaryWriter;
-  _buffer: Buffer;
-  _position: number;
-  _length: number;
-  constructor(arg1?: undefined | Buffer | Uint8Array | null) {
-    this.writer = new BinaryWriter(arg1);
-  }
-
-  get length(): number {
-    return this.writer.length;
-  }
-
-  get position(): number {
-    return this.writer.position;
-  }
-
-  set position(value: number) {
-    this.writer.position = value;
-  }
-
-  writeBoolean(value: boolean): void {
-    this.writer.writeBoolean(value);
-  }
-
-  writeByte(value: number): void {
-    this.writer.writeByte(value);
-  }
-  writeSameByte(value: number, repeats: number): void {
-    this.writer.writeSameByte(value, repeats);
-  }
-  writeSignedByte(value: number): void {
-    this.writer.writeSignedByte(value);
-  }
-  writeShort(value: number): void {
-    this.writer.writeShort(value);
-  }
-  writeUnsignedShort(value: number): void {
-    this.writer.writeUnsignedShort(value);
-  }
-  writeInt(value: number): void {
-    this.writer.writeInt(value);
-  }
-  writeUnsignedInt(value: number): void {
-    this.writer.writeUnsignedInt(value);
-  }
-  writeLong(value: string | number): void {
-    this.writer.writeLong(value);
-  }
-  writeUnsignedLong(value: string | number): void {
-    this.writer.writeUnsignedLong(value);
-  }
-  writeFloat(value: number): void {
-    this.writer.writeFloat(value);
-  }
-  writeDouble(value: number): void {
-    this.writer.writeDouble(value);
-  }
-  writeChar(character: string | number, encoding: Encoding): void {
-    this.writer.writeChar(character, encoding);
-  }
-  writeChars(characters: string | number[], encoding: Encoding): void {
-    this.writer.writeChars(characters, encoding);
-  }
-  clear(): void {
-    this.writer.clear();
-  }
-  toArray(): number[] {
-    return this.writer.toArray();
-  }
-  toUint8Array(): Uint8Array {
-    return this.writer.toUint8Array();
-  }
-
-  public appendByte(value: number): this {
-    this.writeByte(value);
-    return this;
-  }
-
-  public appendBytes(bytes: byte[]) {
-    for (let i = 0; i < bytes.length; i++) {
-      if (!Number.isNaN(bytes[i])) {
-        this.appendByte(bytes[i]);
-      }
-    }
-  }
-
-  public writeEnum(value: number): this {
-    //this.writeUnsignedInt(value);
-    let bytes = [0, 0, 0, 0];
-
-    for (let i = 0; i < bytes.length; i++) {
-      var byte = value & 0xff;
-      bytes[i] = byte;
-      value = (value - byte) / 256;
-    }
-    this.appendBytes(bytes);
-    return this;
-  }
-
-  writeBytes(bytes: byte[]): this {
-    for (let i = 0; i < bytes.length; i++) this.appendByte(bytes[i]);
-
-    // writer.Write(bytes);
-    return this;
-  }
-
-  public writeVarInt(value: number): this {
-    if (value < 0) throw "negative value invalid";
-
-    if (value < 0xfd) {
-      this.appendByte(value);
-    } else if (value <= 0xffff) {
-      let B = (value & 0x0000ff00) >> 8;
-      let A = value & 0x000000ff;
-
-      // TODO check if the endianess is correct, might have to reverse order of appends
-      this.appendByte(0xfd);
-      this.appendByte(A);
-      this.appendByte(B);
-    } else if (value <= 0xffffffff) {
-      let C = (value & 0x00ff0000) >> 16;
-      let B = (value & 0x0000ff00) >> 8;
-      let A = value & 0x000000ff;
-
-      // TODO check if the endianess is correct, might have to reverse order of appends
-      this.appendByte(0xfe);
-      this.appendByte(A);
-      this.appendByte(B);
-      this.appendByte(C);
-    } else {
-      let D = (value & 0xff000000) >> 24;
-      let C = (value & 0x00ff0000) >> 16;
-      let B = (value & 0x0000ff00) >> 8;
-      let A = value & 0x000000ff;
-
-      // TODO check if the endianess is correct, might have to reverse order of appends
-      this.appendByte(0xff);
-      this.appendByte(A);
-      this.appendByte(B);
-      this.appendByte(C);
-      this.appendByte(D);
-    }
-    return this;
-  }
-
-  public writeTimestamp(obj: Timestamp): this {
-    let num = obj.value;
-
-    let a = (num & 0xff000000) >> 24;
-    let b = (num & 0x00ff0000) >> 16;
-    let c = (num & 0x0000ff00) >> 8;
-    let d = num & 0x000000ff;
-
-    let bytes = [d, c, b, a];
-    this.appendBytes(bytes);
-    return this;
-  }
-
-  public writeDateTime(obj: Date): this {
-    let num = (obj.getTime() / 1000) | 0;
-
-    let a = (num & 0xff000000) >> 24;
-    let b = (num & 0x00ff0000) >> 16;
-    let c = (num & 0x0000ff00) >> 8;
-    let d = num & 0x000000ff;
-
-    let bytes = [d, c, b, a];
-    this.appendBytes(bytes);
-    return this;
-  }
-
-  rawString(value: string): number[] {
-    var data = [];
-    for (var i = 0; i < value.length; i++) {
-      data.push(value.charCodeAt(i));
-    }
-    return data;
-  }
-
-  public writeByteArray(bytes: number[] | Uint8Array) {
-    if (bytes instanceof Uint8Array) {
-      bytes = Array.from(bytes);
-    }
-    this.writeVarInt(bytes.length);
-    this.writeBytes(bytes);
-    return this;
-  }
-
-  public writeString(text: string): this {
-    let bytes = this.rawString(text);
-    this.writeVarInt(bytes.length);
-    this.writeBytes(bytes);
-    return this;
-  }
-
-  public emitUInt32(value: number): this {
-    if (value < 0) throw "negative value invalid";
-
-    let D = (value & 0xff000000) >> 24;
-    let C = (value & 0x00ff0000) >> 16;
-    let B = (value & 0x0000ff00) >> 8;
-    let A = value & 0x000000ff;
-
-    // TODO check if the endianess is correct, might have to reverse order of appends
-    this.appendByte(0xff);
-    this.appendByte(A);
-    this.appendByte(B);
-    this.appendByte(C);
-    this.appendByte(D);
-
-    return this;
-  }
-
-  public writeBigInteger(value: BigInt) {
-    return this.writeBigIntegerString(value.toString());
-  }
-
-  public writeBigIntegerString(value: string) {
-    let bytes: number[] = [];
-
-    if (value == "0") {
-      bytes = [0];
-    } else if (value.startsWith("-1")) {
-      throw new Error("Unsigned bigint serialization not suppoted");
-    } else {
-      let hex = BigInt(value).toString(16);
-      if (hex.length % 2) hex = "0" + hex;
-      const len = hex.length / 2;
-      var i = 0;
-      var j = 0;
-      while (i < len) {
-        bytes.unshift(parseInt(hex.slice(j, j + 2), 16)); // little endian
-        i += 1;
-        j += 2;
-      }
-      bytes.push(0); // add sign at the end
-    }
-    return this.writeByteArray(bytes);
-  }
-
-  public writeSignature(signature: Signature): this {
-    if (!signature) {
-      this.writeByte(SignatureKind.None);
-      return this;
-    }
-    this.writeByte(signature.Kind);
-    signature.SerializeData(this);
-    return this;
-  }
-
-  public AppendHexEncoded(bytes: string): this {
-    let localEncoded = hexStringToBytes(bytes);
-    this.writeVarInt(localEncoded.length);
-    /*for (let i = 0; i < localEncoded.length; i++) {
-      if (!Number.isNaN(localEncoded[i])) {
-        this.appendByte(localEncoded[i]);
-      }
-    }*/
-
-    this.appendBytes(localEncoded);
-    return this;
-  }
-}

package/src/core/types/Extensions/index.ts

@@ -1,4 +0,0 @@
-export * from "./PBinaryReader";
-export * from "./PBinaryWriter";
-export * from "./Base16";
-export * from "./Describer";