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

package/src/core/types/PhantasmaKeys.ts

@@ -1,119 +0,0 @@
-import { IKeyPair } from "../interfaces/IKeyPair";
-import { Address } from "./Address";
-import base58 from "bs58";
-import WIF from "wif";
-import { Signature } from "../interfaces/Signature";
-import {
-  hexStringToUint8Array,
-  stringToUint8Array,
-  uint8ArrayToBytes,
-  uint8ArrayToHex,
-  uint8ArrayToString,
-  uint8ArrayToStringDefault,
-} from "../utils";
-import { Ed25519Signature } from "./Ed25519Signature";
-import pkg from 'elliptic';
-import { Entropy } from "./Entropy";
-import {
-  generateNewWif,
-  getAddressFromWif,
-  getPublicKeyFromPrivateKey,
-  getWifFromPrivateKey,
-} from "../tx";
-const { eddsa } = pkg;
-const ed25519 = new eddsa("ed25519");
-
-export class PhantasmaKeys implements IKeyPair {
-  private _privateKey: Uint8Array;
-  public get PrivateKey() {
-    return this._privateKey;
-  }
-  private _publicKey: Uint8Array;
-  public get PublicKey() {
-    return this._publicKey;
-  }
-  public readonly Address: Address;
-
-  public static readonly PrivateKeyLength = 32;
-
-  constructor(privateKey: Uint8Array) {
-    if (privateKey.length == 64) {
-      privateKey = privateKey.slice(0, 32);
-    }
-
-    if (privateKey.length != PhantasmaKeys.PrivateKeyLength) {
-      throw new Error(
-        `privateKey should have length ${PhantasmaKeys.PrivateKeyLength} but has ${privateKey.length}`
-      );
-    }
-
-    this._privateKey = new Uint8Array(PhantasmaKeys.PrivateKeyLength);
-    this._privateKey.set(privateKey);
-    let wif = getWifFromPrivateKey(uint8ArrayToHex(privateKey));
-
-    const privateKeyString = uint8ArrayToHex(this._privateKey);
-    const privateKeyBuffer = Buffer.from(privateKeyString, "hex");
-    const publicKey = ed25519.keyFromSecret(privateKeyBuffer).getPublic();
-    this._publicKey = publicKey;
-
-    this.Address = Address.FromKey(this);
-  }
-
-  public toString() {
-    return this.Address.Text;
-  }
-
-  public static generate(): PhantasmaKeys {
-    const privateKey = Entropy.GetRandomBytes(PhantasmaKeys.PrivateKeyLength);
-
-    const pair = new PhantasmaKeys(privateKey);
-    return pair;
-  }
-
-  public static fromWIF(wif: string): PhantasmaKeys {
-    if (!wif) {
-      throw new Error("WIF required");
-    }
-
-    let data = base58.decode(wif); // checkdecode
-    if (data.length == 38) {
-      data = data.slice(0, 34);
-    }
-
-    if (data.length != 34 || data[0] != 0x80 || data[33] != 0x01) {
-      throw new Error("Invalid WIF format");
-    }
-
-    const privateKey = data.slice(1, 33);
-    return new PhantasmaKeys(privateKey);
-  }
-
-  public toWIF(): string {
-    const privateKeyString = uint8ArrayToHex(this._privateKey);
-    const privatekeyBuffer = Buffer.from(privateKeyString, "hex");
-    const wif = WIF.encode(128, privatekeyBuffer, true); //uint8ArrayToHex(data); // .base58CheckEncode();
-    return wif;
-  }
-
-  public static xor(x: Uint8Array, y: Uint8Array): Uint8Array {
-    if (x.length != y.length) {
-      throw new Error("x and y should have the same length");
-    }
-    const result = new Uint8Array(x.length);
-    for (let i = 0; i < x.length; i++) {
-      result[i] = x[i] ^ y[i];
-    }
-    return result;
-  }
-
-  public Sign(
-    msg: Uint8Array,
-    customSignFunction?: (
-      msg: Uint8Array,
-      privateKey: Uint8Array,
-      publicKey: Uint8Array
-    ) => Uint8Array
-  ): Signature {
-    return Ed25519Signature.Generate(this, msg);
-  }
-}

package/src/core/types/Serialization.ts

@@ -1,211 +0,0 @@
-import { Type } from "typescript";
-import { Base16, PBinaryReader, PBinaryWriter } from "./Extensions";
-import { Timestamp } from "./Timestamp";
-import { ISerializable } from "../interfaces";
-import { stringToUint8Array, uint8ArrayToBytes } from "../utils";
-
-export interface CustomReader {
-  (reader: PBinaryReader): any;
-}
-export interface CustomWriter {
-  (writer: PBinaryWriter, obj: any): void;
-}
-//function CustomWriter(writer: PBinaryWriter, obj: any): void;
-//function CustomReader(reader: PBinaryReader): any;
-
-export class CustomSerializer {
-  readonly Read: CustomReader;
-  readonly Write: CustomWriter;
-  constructor(reader: CustomReader, writer: CustomWriter) {
-    this.Read = reader;
-    this.Write = writer;
-  }
-}
-
-export class Serialization<T> {
-  private static _customSerializers: Map<string, CustomSerializer> = new Map<
-    string,
-    CustomSerializer
-  >(); //: { [key: string]: CustomSerializer };
-
-  static RegisterType<T>(type: T, reader: CustomReader, writer: CustomWriter) {
-    Serialization._customSerializers[typeof type] = new CustomSerializer(
-      reader,
-      writer
-    );
-  }
-
-  static SerializeEnum(obj: any): Uint8Array {
-    if (!obj) {
-      return new Uint8Array();
-    }
-
-    if (obj instanceof Uint8Array) {
-      return obj;
-    }
-
-    let writer = new PBinaryWriter();
-    writer.writeEnum(obj);
-    return writer.toUint8Array();
-  }
-
-  static Serialize(obj: any): Uint8Array {
-    if (!obj) {
-      return new Uint8Array();
-    }
-
-    if (obj instanceof Uint8Array) {
-      return obj;
-    }
-
-    //let jsonString = JSON.stringify(obj);
-    let writer = new PBinaryWriter();
-    this.SerializeObject(writer, obj, typeof obj);
-    //let jsonAsUint8 = new TextEncoder().encode(jsonString);
-    return writer.toUint8Array();
-  }
-
-  static SerializeObject(writer: PBinaryWriter, obj: any, type: any | null) {
-    if (type == null || type == undefined) {
-      type = typeof obj;
-      this.SerializeObject(writer, obj, type);
-      return;
-    }
-
-    if (Serialization._customSerializers.has(typeof type)) {
-      var serializer = Serialization._customSerializers[typeof type];
-      serializer.Write(writer, obj);
-      return;
-    }
-
-    /*if (typeof obj == "void") {
-      return;
-    }*/
-    const structType: any = Object.getPrototypeOf(obj).constructor.name;
-    const result = Object.apply(structType);
-    let localType = Object.apply(typeof type);
-    //console.log(localType);
-
-    if (obj instanceof Boolean || typeof obj == "boolean") {
-      writer.writeByte(obj ? 1 : 0);
-      return;
-    } else if (obj instanceof Number || typeof obj == "number") {
-      writer.writeByte(stringToUint8Array(obj.toString()).length);
-      writer.writeVarInt(obj as number);
-      return;
-    } else if (obj instanceof BigInt || typeof obj == "bigint") {
-      writer.writeBigInteger(obj);
-    } else if (obj instanceof String || typeof obj == "string") {
-      writer.writeString(obj as string);
-      return;
-    } else if (obj instanceof Timestamp) {
-      writer.writeTimestamp(obj);
-      return;
-    } else if (obj instanceof Date) {
-      writer.writeDateTime(obj);
-      return;
-    } else if (
-      typeof obj.UnserializeData === "function" &&
-      typeof obj.SerializeData === "function"
-    ) {
-      (obj as ISerializable).SerializeData(writer);
-      return;
-    } else if (Array.isArray(obj)) {
-      writer.writeVarInt(obj.length);
-      obj.forEach((entry) => {
-        this.SerializeObject(writer, entry, typeof entry);
-      });
-      return;
-    } else if (Object.getPrototypeOf(type) == "enum") {
-      writer.writeByte(obj as unknown as number);
-      return;
-    } else if (obj instanceof Uint8Array) {
-      writer.writeByteArray(Array.from(obj));
-    } else {
-      // TODO: Add support for other types
-      // Get the keys of the object
-      const fields = Object.keys(obj);
-      fields.forEach((field) => {
-        let value = obj[field];
-        this.SerializeObject(writer, value, typeof value);
-      });
-    }
-  }
-
-  static Unserialize<T>(
-    bytesOrBytes: Uint8Array | PBinaryReader,
-    type?: any
-  ): T {
-    if (bytesOrBytes instanceof PBinaryReader) {
-      return Serialization.UnserializeObject(bytesOrBytes, type) as T;
-    }
-    if (!bytesOrBytes || bytesOrBytes.length === 0) {
-      return null as T;
-    }
-    //let type = Object.prototype.propertyIsEnumerable(T);
-    let stream: PBinaryReader = new PBinaryReader(bytesOrBytes);
-    return Serialization.UnserializeObject<T>(stream, type) as T;
-  }
-
-  static UnserializeObject<T extends any>(reader: PBinaryReader, type: any): T {
-    if (Serialization._customSerializers.has(typeof type)) {
-      var serializer = Serialization._customSerializers[typeof type];
-      return serializer.Read(reader);
-    }
-
-    if (type == null || type == undefined) {
-      return null as T;
-    }
-
-    let localType; //: typeof type;
-
-    if (type.name != undefined) {
-      let className = type.name as T;
-      localType = Object.apply(className);
-    } else {
-      localType = new type();
-    }
-
-    if (
-      localType instanceof Boolean ||
-      typeof localType == "boolean" ||
-      type.name == "Boolean"
-    ) {
-      return reader.readBoolean() as unknown as T;
-    } else if (localType instanceof Number || typeof localType == "number") {
-      return reader.readVarInt() as unknown as T;
-    } else if (localType instanceof BigInt || typeof localType == "bigint") {
-      return reader.readBigInteger() as unknown as T;
-    } else if (localType instanceof String || typeof localType == "string") {
-      return reader.readVarString() as unknown as T;
-    } else if (localType instanceof Timestamp) {
-      return new Timestamp(reader.readVarInt()) as unknown as T;
-    } else if (
-      typeof localType.UnserializeData === "function" &&
-      typeof localType.SerializeData === "function"
-    ) {
-      let obj = localType;
-      obj.UnserializeData(reader);
-      return obj as T;
-    } else if (Array.isArray(type)) {
-      var len = reader.readByte();
-      var arr = new Array(len);
-      for (let i = 0; i < len; i++) {
-        arr[i] = this.UnserializeObject(reader, type[i]);
-      }
-      return arr as unknown as T;
-    } else if (Object.getPrototypeOf(type) == "enum") {
-      return reader.readByte() as unknown as T;
-    } else {
-      const fields = Object.keys(localType as T);
-      /*console.log(fields);
-      fields.forEach((field) => {
-        localType[field] = this.UnserializeObject(
-          reader,
-          typeof localType[field]
-        );
-      });
-      return localType as T;*/
-    }
-  }
-}

package/src/core/types/Stack.ts

@@ -1,46 +0,0 @@
-import { IStack } from "../interfaces";
-
-export class Stack<T> implements IStack<T> {
-  private storage: T[] = [];
-
-  constructor(private capacity: number = Infinity) {}
-
-  push(item: T): void {
-    if (this.size() === this.capacity) {
-      throw Error("Stack has reached max capacity, you cannot add more items");
-    }
-    this.storage.push(item);
-  }
-
-  pop(): T | undefined {
-    return this.storage.pop();
-  }
-
-  peek(): T | undefined {
-    return this.storage[this.size() - 1];
-  }
-
-  size(): number {
-    return this.storage.length;
-  }
-
-  isEmpty(): boolean {
-    return this.size() === 0;
-  }
-
-  toArray(): T[] {
-    return this.storage;
-  }
-
-  clear(): void {
-    this.storage = [];
-  }
-
-  toString(): string {
-    return this.storage.toString();
-  }
-
-  isFull(): boolean {
-    return this.capacity === this.size();
-  }
-}

package/src/core/types/Timestamp.ts

@@ -1,93 +0,0 @@
-export class Timestamp {
-  public value: number;
-
-  constructor(value: number) {
-    this.value = value;
-  }
-
-  public toString() {
-    return new Date(this.value * 1000).toUTCString();
-  }
-
-  public toStringFormat(format: string) {
-    return new Date(this.value * 1000).toUTCString();
-  }
-
-  public static now = Date.now();
-  public static null = new Timestamp(0);
-
-  public compareTo(other: Timestamp) {
-    if (other.value === this.value) {
-      return 0;
-    }
-
-    if (this.value < other.value) {
-      return -1;
-    }
-
-    return 1;
-  }
-
-  public equals(obj: any) {
-    if (!(obj instanceof Timestamp)) {
-      return false;
-    }
-
-    return this.value === obj.value;
-  }
-
-  public getHashCode() {
-    return this.value;
-  }
-
-  public getSize() {
-    return 4;
-  }
-
-  public static equal(A: Timestamp, B: Timestamp) {
-    return A.value === B.value;
-  }
-
-  public static notEqual(A: Timestamp, B: Timestamp) {
-    return !(A.value === B.value);
-  }
-
-  public static lessThan(A: Timestamp, B: Timestamp) {
-    return A.value < B.value;
-  }
-
-  public static greaterThan(A: Timestamp, B: Timestamp) {
-    return A.value > B.value;
-  }
-
-  public static lessThanOrEqual(A: Timestamp, B: Timestamp) {
-    return A.value <= B.value;
-  }
-
-  public static greaterThanOrEqual(A: Timestamp, B: Timestamp) {
-    return A.value >= B.value;
-  }
-
-  public static subtract(A: Timestamp, B: Timestamp) {
-    return A.value - B.value;
-  }
-
-  public static fromNumber(ticks: number) {
-    return new Timestamp(ticks);
-  }
-
-  public static fromDate(time: Date) {
-    return new Timestamp(time.getTime() / 1000);
-  }
-
-  public static addTimeSpan(A: Timestamp, B: number) {
-    return A.value + B;
-  }
-  public static subtractTimeSpan(A: Timestamp, B: number) {
-    return A.value - B;
-  }
-
-  public static Serialize() {}
-
-  public static Unserialize() {}
-}

package/src/core/types/index.ts

@@ -1,11 +0,0 @@
-export * from "./Consensus";
-export * from "./Timestamp";
-export * from "./Stack";
-export * from "./Address";
-export * from "./Contract";
-export * from "./Ed25519Signature";
-export * from "./PhantasmaKeys";
-export * from "./DomainSettings";
-export * from "./Entropy";
-export * from "./Extensions";
-export * from "./Serialization";

package/src/core/utils/index.ts

@@ -1,206 +0,0 @@
-export function hexToByteArray(hexBytes: string) {
-  const res = [hexBytes.length / 2];
-  for (let i = 0; i < hexBytes.length; i += 2) {
-    const hexdig = hexBytes.substr(i, 2);
-    if (hexdig == '') {
-      res.push(0);
-    } else res.push(parseInt(hexdig, 16));
-  }
-  return res;
-}
-
-export function HexToBytes(hex: string) {
-  return hexToByteArray(hex);
-}
-
-export function hexToBuffer(hex: string) {
-  return new Uint8Array(hexToByteArray(hex));
-}
-
-export function bufferToHex(buffer: ArrayBuffer | ArrayLike<number> | Uint8Array) {
-  return byteArrayToHex(buffer);
-}
-
-export function hexStringToBytes(hexString: string) {
-  for (var bytes = [], c = 0; c < hexString.length; c += 2)
-    bytes.push(parseInt(hexString.substr(c, 2), 16));
-  return bytes;
-}
-
-export function byteArrayToHex(arr: ArrayBuffer | ArrayLike<number> | Uint8Array): string {
-  if (typeof arr !== 'object') {
-    throw new Error(`ba2hex expects an array.Input was ${arr}`);
-  }
-  let result = '';
-  const intArray = new Uint8Array(arr);
-  for (const i of intArray) {
-    let str = i.toString(16);
-    str = str.length === 0 ? '00' : str.length === 1 ? '0' + str : str;
-    result += str;
-  }
-  return result;
-}
-
-export function BytesToHex(bytes: Uint8Array | ArrayBuffer | ArrayLike<number>) {
-  return byteArrayToHex(bytes);
-}
-
-export function reverseHex(hex: string): string {
-  let out = '';
-  for (let i = hex.length - 2; i >= 0; i -= 2) {
-    out += hex.substr(i, 2);
-  }
-  return out;
-}
-
-export function getDifficulty(transactionHash: string) {
-  let bytes = hexStringToBytes(transactionHash).reverse();
-  let result = 0;
-
-  for (let i = 0; i < bytes.length; i++) {
-    var n = bytes[i];
-    for (let j = 0; j < 8; j++) {
-      if ((bytes[i] & (1 << j)) != 0) {
-        result = 1 + (i << 3) + j;
-      }
-    }
-  }
-
-  return 256 - result;
-}
-
-export function decodeBase16(hex: string) {
-  let str = '';
-  for (let i = 0; i < hex.length; i += 2) {
-    str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
-  }
-  return str;
-}
-
-export function encodeBase16(str: string) {
-  return str
-    .split('')
-    .map((c) => c.charCodeAt(0).toString(16).padStart(2, '0'))
-    .join('')
-    .toUpperCase();
-}
-
-export function uint8ArrayToString(array: Uint8Array): string {
-  let result = '';
-  for (let i = 0; i < array.length; i++) {
-    result += String.fromCharCode(array[i]);
-  }
-  return result;
-}
-
-export function uint8ArrayToStringDefault(array: Uint8Array): string {
-  let result = '';
-  for (let i = 0; i < array.length; i++) {
-    result += array[i].toString(16);
-  }
-  return result;
-}
-
-export function uint8ArrayToNumberArray(array: Uint8Array): number[] {
-  let result = [];
-  for (let i = 0; i < array.length; i++) {
-    result.push(array[i]);
-  }
-  return result;
-}
-
-export function stringToUint8Array(str: string): Uint8Array {
-  let result = new Uint8Array(str.length);
-  for (let i = 0; i < str.length; i++) {
-    result[i] = str.charCodeAt(i);
-  }
-  return result;
-}
-
-export function hexStringToUint8Array(str: string): Uint8Array {
-  let result = new Uint8Array(str.length);
-  for (let i = 0; i < str.length; i++) {
-    result[i] = str.charCodeAt(i).toString(16).charCodeAt(0);
-  }
-  return result;
-}
-
-export function arrayNumberToUint8Array(arr: number[]): Uint8Array {
-  let result = new Uint8Array(arr.length);
-  for (let i = 0; i < arr.length; i++) {
-    result[i] = arr[i];
-  }
-  return result;
-}
-
-export function uint8ArrayToBytes(array: Uint8Array): number[] {
-  let result = [];
-  for (let i = 0; i < array.length; i++) {
-    result.push(array[i]);
-  }
-  return result;
-}
-
-export function uint8ArrayToHex(arr: Uint8Array): string {
-  let hexString = '';
-  for (let i = 0; i < arr.length; i++) {
-    hexString += arr[i].toString(16).padStart(2, '0');
-  }
-  return hexString;
-}
-
-export function numberToByteArray(num: number, size?: number): Uint8Array {
-  if (size === undefined) {
-    if (num < 0xfd) {
-      size = 1;
-    } else if (num <= 0xfffd) {
-      size = 2;
-    } else if (num <= 0xffffd) {
-      size = 3;
-    } else if (num <= 0xfffffffd) {
-      size = 4;
-    } else if (num <= 0xffffffff) {
-      size = 5;
-    } else if (num <= 0xffffffffffffffff) {
-      size = 9;
-    }
-  }
-  var bytes = new Uint8Array(size);
-
-  var i = 0;
-  do {
-    bytes[i++] = num & 0xff;
-    num = num >> 8;
-  } while (num);
-  return bytes;
-}
-
-export function bigIntToByteArray(bigint: bigint): Uint8Array {
-  // Get a big-endian byte representation of the bigint
-  var bytes = bigint.toString(16).padStart(64, '0');
-  var byteArray = new Uint8Array(bytes.length / 2);
-  for (var i = 0; i < bytes.length; i += 2) {
-    byteArray[i / 2] = parseInt(bytes.substring(i, i + 2), 16);
-  }
-  return byteArray;
-}
-
-export const hex2ascii = (hexx) => {
-  const hex = hexx.toString();
-  let str = '';
-  for (let i = 0; i < hex.length; i += 2) {
-    const char = hex.substr(i, 2);
-    const charCode = String.fromCharCode(parseInt(char, 16));
-    // console.log('char', char, 'charCode', charCode);
-    str += charCode;
-  }
-  return str;
-};
-
-export const Int2Buffer = (i: number): Buffer => {
-  let hex = i.toString(16).toUpperCase();
-  if (hex.length % 2 === 1) {
-    hex = '0' + hex;
-  }
-  return Buffer.from(hex, 'hex');
-};

package/src/core/vm/Contracts.ts

@@ -1,17 +0,0 @@
-
-export enum Contracts {
-  GasContractName = "gas",
-  BlockContractName = "block",
-  StakeContractName = "stake",
-  SwapContractName = "swap",
-  AccountContractName = "account",
-  ConsensusContractName = "consensus",
-  GovernanceContractName = "governance",
-  StorageContractName = "storage",
-  ValidatorContractName = "validator",
-  InteropContractName = "interop",
-  ExchangeContractName = "exchange",
-  PrivacyContractName = "privacy",
-  RelayContractName = "relay",
-  RankingContractName = "ranking"
-}