phantasma-sdk-ts 0.1.71

package/src/core/types/Entropy.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,247 @@
+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

@@ -0,0 +1,278 @@
+//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

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