phantasma-sdk-ts 0.1.71

package/src/core/types/PhantasmaKeys.ts

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

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

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

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

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

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

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