phantasma-sdk-ts 0.1.71

package/src/core/tx/Transaction.ts

@@ -0,0 +1,258 @@
+import pkg from 'elliptic';
+const { eddsa } = pkg;
+import { Decoder, ScriptBuilder } from '../vm';
+import {
+  hexStringToBytes,
+  byteArrayToHex,
+  getDifficulty,
+  stringToUint8Array,
+  uint8ArrayToHex,
+  uint8ArrayToString,
+  uint8ArrayToStringDefault,
+  hexStringToUint8Array,
+  hexToByteArray,
+} from '../utils';
+import hexEncoding from 'crypto-js/enc-hex';
+import SHA256 from 'crypto-js/sha256';
+import { ISerializable, ISignature, Signature } from '../interfaces';
+import { Base16, PBinaryReader, PBinaryWriter, PhantasmaKeys } from '../types';
+import { getWifFromPrivateKey } from './utils';
+const curve = new eddsa('ed25519');
+
+export class Transaction implements ISerializable {
+  script: string; // Should be HexString
+  nexusName: string;
+  chainName: string;
+  payload: string; // Should be HexString
+  expiration: Date;
+  signatures: Array<Signature>;
+  hash: string;
+
+  public static FromBytes(serializedData: string): Transaction {
+    let transaction = new Transaction('', '', '', new Date(), '');
+    return transaction.unserialize(serializedData);
+  }
+
+  constructor(
+    nexusName: string,
+    chainName: string,
+    script: string, // Should be HexString
+    expiration: Date,
+    payload: string // Should be HexString
+  ) {
+    this.nexusName = nexusName;
+    this.chainName = chainName;
+    this.script = script;
+    this.expiration = expiration;
+    this.payload = payload == null || payload == '' ? '7068616e7461736d612d7473' : payload;
+    this.signatures = [];
+  }
+
+  public sign(wif: string) {
+    let _keys = PhantasmaKeys.fromWIF(wif);
+    const msg = this.ToByteAray(false);
+    let sig: Signature = _keys.Sign(msg);
+    let sigs: Signature[] = [];
+    if (this.signatures != null && this.signatures.length > 0) {
+      sigs = this.signatures;
+    }
+    sigs.push(sig);
+
+    this.signatures = sigs;
+    //const signature = this.getSign(this.toString(false), privateKey);
+    //this.signatures.unshift({ signature, kind: 1 });
+  }
+
+  public signWithPrivateKey(privateKey: string) {
+    const msg = this.ToByteAray(false);
+    let sig: Signature = PhantasmaKeys.fromWIF(getWifFromPrivateKey(privateKey)).Sign(msg);
+    let sigs: Signature[] = [];
+    if (this.signatures != null && this.signatures.length > 0) {
+      sigs = this.signatures;
+    }
+    sigs.push(sig);
+
+    this.signatures = sigs;
+  }
+
+  public signWithKeys(keys: PhantasmaKeys) {
+    const msg = this.ToByteAray(false);
+    let sig: Signature = keys.Sign(msg);
+    let sigs: Signature[] = [];
+    if (this.signatures != null && this.signatures.length > 0) {
+      sigs = this.signatures;
+    }
+    sigs.push(sig);
+
+    this.signatures = sigs;
+  }
+
+  public ToByteAray(withSignature: boolean): Uint8Array {
+    let writer = new PBinaryWriter();
+    writer.writeString(this.nexusName);
+    writer.writeString(this.chainName);
+    writer.AppendHexEncoded(this.script);
+    writer.writeDateTime(this.expiration);
+    writer.AppendHexEncoded(this.payload);
+    if (withSignature) {
+      writer.writeVarInt(this.signatures.length);
+      this.signatures.forEach((sig) => {
+        writer.writeSignature(sig);
+        //writer.writeByte(sig.kind);
+        //writer.writeByteArray(stringToUint8Array(sig.signature));
+      });
+    }
+
+    return writer.toUint8Array();
+  }
+
+  public UnserializeData(reader: PBinaryReader) {
+    this.nexusName = reader.readString();
+    this.chainName = reader.readString();
+    this.script = uint8ArrayToStringDefault(reader.readByteArray());
+    let time = reader.readTimestamp();
+    this.expiration = new Date(time.toString());
+    this.payload = uint8ArrayToStringDefault(reader.readByteArray());
+    let sigCount = reader.readVarInt();
+    for (let i = 0; i < sigCount; i++) {
+      let sig = reader.readSignatureV2();
+      this.signatures.push(sig);
+    }
+  }
+
+  public SerializeData(writer: PBinaryWriter) {
+    writer.writeString(this.nexusName);
+    writer.writeString(this.chainName);
+    writer.writeByteArray(Base16.decodeUint8Array(this.script));
+    writer.writeDateTime(this.expiration);
+    writer.writeByteArray(Base16.decodeUint8Array(this.payload));
+    writer.writeVarInt(this.signatures.length);
+    this.signatures.forEach((sig) => {
+      writer.writeSignature(sig);
+    });
+  }
+
+  public toString(withSignature: boolean): string {
+    /*const utc = Date.UTC(
+      this.expiration.getUTCFullYear(),
+      this.expiration.getUTCMonth(),
+      this.expiration.getUTCDate(),
+      this.expiration.getUTCHours(),
+      this.expiration.getUTCMinutes(),
+      this.expiration.getUTCSeconds()
+    );
+    let num = utc / 1000;
+
+    let a = (num & 0xff000000) >> 24;
+    let b = (num & 0x00ff0000) >> 16;
+    let c = (num & 0x0000ff00) >> 8;
+    let d = num & 0x000000ff;
+
+    let expirationBytes = [d, c, b, a];*/
+
+    let sb = new ScriptBuilder()
+      .EmitVarString(this.nexusName)
+      .EmitVarString(this.chainName)
+      .EmitVarInt(this.script.length / 2)
+      .AppendHexEncoded(this.script)
+      .EmitTimestamp(this.expiration)
+      .EmitVarInt(this.payload.length / 2)
+      .AppendHexEncoded(this.payload);
+
+    if (withSignature) {
+      sb.EmitVarInt(this.signatures.length);
+      this.signatures.forEach((sig) => {
+        console.log('adding signature ', sig);
+        if (sig.Kind == 1) {
+          sb.AppendByte(1); // Signature Type
+          sb.EmitVarInt(sig.Bytes.length / 2);
+          sb.AppendHexEncoded(uint8ArrayToHex(sig.Bytes));
+        } else if (sig.Kind == 2) {
+          sb.AppendByte(2); // ECDSA Signature
+          sb.AppendByte(1); // Curve type secp256k1
+          sb.EmitVarInt(sig.Bytes.length / 2);
+          sb.AppendHexEncoded(uint8ArrayToHex(sig.Bytes));
+        }
+      });
+    }
+    return sb.str;
+  }
+
+  public ToStringEncoded(withSignature: boolean): string {
+    return Base16.encodeUint8Array(this.ToByteAray(withSignature));
+  }
+
+  public getHash() {
+    let generatedHash = SHA256(hexEncoding.parse(this.toString(false)));
+    this.hash = byteArrayToHex(hexStringToBytes(generatedHash.toString(hexEncoding)).reverse());
+    return this.hash;
+  }
+
+  public mineTransaction(difficulty: number) {
+    if (difficulty < 0 || difficulty > 256) {
+      console.log('Error adding difficulty');
+      return;
+    }
+
+    let nonce = 0;
+    let deepCopy = new Transaction(
+      JSON.parse(JSON.stringify(this.nexusName)),
+      JSON.parse(JSON.stringify(this.chainName)),
+      JSON.parse(JSON.stringify(this.script)),
+      this.expiration,
+      JSON.parse(JSON.stringify(this.payload))
+    );
+    let payload = Buffer.alloc(4);
+
+    while (true) {
+      if (getDifficulty(deepCopy.getHash()) >= difficulty) {
+        this.payload = deepCopy.payload;
+        console.log('It took ' + nonce + ' iterations to get a difficulty of >' + difficulty);
+        return;
+      }
+
+      nonce++;
+
+      payload[0] = (nonce >> 0) & 0xff;
+      payload[1] = (nonce >> 8) & 0xff;
+      payload[2] = (nonce >> 16) & 0xff;
+      payload[3] = (nonce >> 24) & 0xff;
+
+      deepCopy.payload = byteArrayToHex(payload);
+    }
+  }
+
+  private getSign(msgHex: string, privateKey: string): string {
+    const msgHashHex = Buffer.from(msgHex, 'hex');
+    const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+
+    const sig = curve.sign(msgHashHex, privateKeyBuffer);
+
+    return sig.toHex();
+  }
+
+  public unserialize(serializedData: string): Transaction {
+    let dec = new Decoder(serializedData);
+    let nexusName = dec.readString();
+    let chainName = dec.readString();
+    let scriptLength = dec.readVarInt();
+    let script = dec.read(scriptLength);
+    let date = new Date(dec.readTimestamp() * 1000);
+    let payloadLength = dec.readVarInt();
+    let payload = dec.read(payloadLength);
+
+    let nTransaction = new Transaction(nexusName, chainName, script, date, payload);
+    let signatureCount = dec.readVarInt();
+    /*for (let i = 0; i < signatureCount; i++) {
+      nTransaction.signatures.push(dec.readSignature());
+    }*/
+    return nTransaction;
+  }
+
+  public static Unserialize(serialized: Uint8Array) {
+    let reader = new PBinaryReader(serialized);
+    let tx = new Transaction('', '', '', new Date(), '');
+    tx.UnserializeData(reader);
+    return tx;
+  }
+}

package/src/core/tx/index.ts

@@ -0,0 +1,2 @@
+export * from './Transaction';
+export * from './utils';

package/src/core/tx/utils.ts

@@ -0,0 +1,106 @@
+import WIF from 'wif';
+import pkg from 'elliptic';
+import base58 from 'bs58';
+import * as bip39 from 'bip39';
+import { hdkey } from 'ethereumjs-wallet';
+import crypto from 'crypto';
+const { eddsa } = pkg;
+const curve = new eddsa('ed25519');
+
+function ab2hexstring(arr: ArrayBuffer | ArrayLike<number>): string {
+  if (typeof arr !== 'object') {
+    throw new Error(`ab2hexstring 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 getPrivateKeyFromWif(wif: string): string {
+  return ab2hexstring(WIF.decode(wif, 128).privateKey);
+}
+
+export function getAddressFromWif(wif: string): string {
+  const curve = new eddsa('ed25519');
+
+  const privateKey = getPrivateKeyFromWif(wif);
+  const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+  const publicKey = curve.keyFromSecret(privateKeyBuffer).getPublic('hex');
+  var addressHex = Buffer.from('0100' + publicKey, 'hex');
+
+  return 'P' + base58.encode(addressHex);
+}
+
+export function getPublicKeyFromPrivateKey(privateKey: string): string {
+  const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+  const publicKey = curve.keyFromSecret(privateKeyBuffer).getPublic('hex');
+  return publicKey;
+}
+
+export function generateNewSeed(): string {
+  let buffer = new Uint8Array(32);
+  let privateKey = Buffer.alloc(32);
+  crypto.getRandomValues(buffer);
+  for (let i = 0; i < 32; ++i) {
+    privateKey.writeUInt8(buffer[i], i);
+  }
+
+  const wif = WIF.encode(128, privateKey, true);
+  const mnemonic = bip39.generateMnemonic();
+  return mnemonic;
+}
+
+export function generateNewSeedWords(): string[] {
+  let buffer = new Uint8Array(32);
+  let privateKey = Buffer.alloc(32);
+  crypto.getRandomValues(buffer);
+  for (let i = 0; i < 32; ++i) {
+    privateKey.writeUInt8(buffer[i], i);
+  }
+
+  const wif = WIF.encode(128, privateKey, true);
+  const mnemonic = bip39.generateMnemonic();
+  const seedWords = mnemonic.split(' ');
+  return seedWords;
+}
+
+export function generateNewWif(): string {
+  let buffer = new Uint8Array(32);
+  let privateKey = Buffer.alloc(32);
+  crypto.getRandomValues(buffer);
+  for (let i = 0; i < 32; ++i) {
+    privateKey.writeUInt8(buffer[i], i);
+  }
+
+  const wif = WIF.encode(128, privateKey, true);
+  return wif;
+}
+
+export function getWifFromPrivateKey(privateKey: string): string {
+  const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+  const wif = WIF.encode(128, privateKeyBuffer, true);
+  return wif;
+}
+
+export function signData(msgHex: string, privateKey: string): string {
+  const msgHashHex = Buffer.from(msgHex, 'hex');
+  const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+
+  const sig = curve.sign(msgHashHex, privateKeyBuffer);
+  const numBytes = sig.toBytes().length;
+
+  return '01' + (numBytes < 16 ? '0' : '') + numBytes.toString(16) + sig.toHex();
+}
+
+export function verifyData(msgHex: string, phaSig: string, address: string): boolean {
+  const msgBytes = Buffer.from(msgHex, 'hex');
+  const realSig = phaSig.substring(4);
+  const pubKey = base58.decode(address.substring(1)).slice(2);
+
+  return curve.verify(msgBytes, realSig, ab2hexstring(pubKey));
+}

package/src/core/types/Address.ts

@@ -0,0 +1,290 @@
+import base58 from 'bs58';
+import { encodeBase16, stringToUint8Array, uint8ArrayToString } from '../utils';
+import SHA256 from 'crypto-js/sha256';
+import hexEncoding from 'crypto-js/enc-hex';
+import { IKeyPair, ISerializable } from '../interfaces';
+import { getPrivateKeyFromWif, getPublicKeyFromPrivateKey, getWifFromPrivateKey } from '../tx';
+import pkg from 'elliptic';
+import { PBinaryWriter, PBinaryReader } from './Extensions';
+const { eddsa } = pkg;
+const curve = new eddsa('ed25519');
+
+export enum AddressKind {
+  Invalid = 0,
+  User = 1,
+  System = 2,
+  Interop = 3,
+}
+
+export class Address implements ISerializable {
+  public static readonly NullText: string = 'NULL';
+  public static readonly LengthInBytes: number = 34;
+  public static readonly MaxPlatformNameLength: number = 10;
+
+  private static NullPublicKey = new Uint8Array(Address.LengthInBytes);
+  public static readonly Null: Address = new Address(Address.NullPublicKey);
+
+  private _bytes: Uint8Array;
+
+  /*public get Kind(): AddressKind {
+        return this.IsNull ? AddressKind.System : (this._bytes[0] >= 3) ? AddressKind.Interop 
+            : (AddressKind)this._bytes[0];
+    }*/
+
+  public get Kind(): AddressKind {
+    if (this.IsNull) {
+      return AddressKind.System;
+    } else if (this._bytes[0] >= 3) {
+      return AddressKind.Interop;
+    } else {
+      return this._bytes[0] as AddressKind;
+    }
+  }
+
+  public get IsSystem(): boolean {
+    return this.Kind == AddressKind.System;
+  }
+
+  public get IsInterop(): boolean {
+    return this.Kind == AddressKind.Interop;
+  }
+
+  public get IsUser(): boolean {
+    return this.Kind == AddressKind.User;
+  }
+
+  /*public get TendermintAddress(): string {
+        return encodeBase16(this._bytes.slice(2).SHA256().slice(0, 20));
+    }
+    public get TendermintAddress() {
+        return SHA256(this._bytes.slice(2)).slice(0, 20).toString('hex');
+    }   
+    */
+
+  public get IsNull(): boolean {
+    if (this._bytes == null || this._bytes.length == 0) {
+      return true;
+    }
+
+    for (let i = 1; i < this._bytes.length; i++) {
+      if (this._bytes[i] != 0) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private _text: string;
+
+  private static _keyToTextCache = new Map<Uint8Array, string>();
+
+  public get Text(): string {
+    if (this.IsNull) {
+      return Address.NullText;
+    }
+
+    if (!this._text) {
+      if (Address._keyToTextCache.has(this._bytes)) {
+        this._text = Address._keyToTextCache.get(this._bytes);
+      }
+
+      if (!this._text) {
+        let prefix: string;
+
+        switch (this.Kind) {
+          case AddressKind.User:
+            prefix = 'P';
+            break;
+          case AddressKind.Interop:
+            prefix = 'X';
+            break;
+          default:
+            prefix = 'S';
+            break;
+        }
+        this._text = prefix + base58.encode(this._bytes);
+        Address._keyToTextCache.set(this._bytes, this._text);
+      }
+    }
+
+    return this._text;
+  }
+
+  private constructor(publicKey: Uint8Array) {
+    let pkFromArray = Array.from(publicKey);
+    if (publicKey.length != Address.LengthInBytes) {
+      throw new Error(
+        `publicKey length must be ${Address.LengthInBytes}, it was ${publicKey.length}}`
+      );
+    }
+    this._bytes = new Uint8Array(Address.LengthInBytes);
+    this._bytes.set(publicKey);
+    this._text = null;
+  }
+
+  public static FromPublickKey(publicKey: Uint8Array): Address {
+    publicKey = publicKey.slice(0, 34);
+    return new Address(publicKey);
+  }
+
+  public static FromText(text: string): Address {
+    return Address.Parse(text);
+  }
+
+  public static Parse(text: string): Address {
+    if (text == null) {
+      return Address.Null;
+    }
+
+    if (text == Address.NullText) {
+      return Address.Null;
+    }
+
+    let addr: Address;
+
+    let originalText = text;
+    let prefix = text[0];
+
+    text = text.slice(1);
+    var bytes = base58.decode(text);
+
+    addr = new Address(bytes);
+
+    switch (prefix) {
+      case 'P':
+        if (addr.Kind != AddressKind.User) {
+          throw new Error(`Invalid address prefix. Expected 'P', got '${prefix}'`);
+        }
+        break;
+      case 'S':
+        if (addr.Kind != AddressKind.System) {
+          throw new Error(`Invalid address prefix. Expected 'S', got '${prefix}'`);
+        }
+        break;
+      case 'X':
+        if (addr.Kind < AddressKind.Interop) {
+          throw new Error(`Invalid address prefix. Expected 'X', got '${prefix}'`);
+        }
+        break;
+      default:
+        throw new Error(`Invalid address prefix. Expected 'P', 'S' or 'X', got '${prefix}'`);
+    }
+
+    /*this._keyToTextCache.values().forEach((value) => {
+      if (value == text) {
+        return Address.FromHash(this._keyToTextCache(value));
+      }*/
+
+    return addr;
+  }
+
+  public static IsValidAddress(text: string): boolean {
+    try {
+      Address.FromText(text);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  public static FromBytes(bytes: Uint8Array): Address {
+    return new Address(bytes);
+  }
+
+  public static FromKey(key: IKeyPair): Address {
+    const bytes = new Uint8Array(Address.LengthInBytes);
+    bytes[0] = AddressKind.User;
+
+    if (key.PublicKey.length == 32) {
+      bytes.set(key.PublicKey, 2);
+    } else if (key.PublicKey.length == 33) {
+      bytes.set(key.PublicKey, 1);
+    } else if (key.PublicKey.length == 64) {
+      bytes.set(key.PublicKey.slice(0, 32), 1);
+    } else {
+      throw new Error('Invalid public key length: ' + key.PublicKey.length);
+    }
+
+    return new Address(bytes);
+  }
+
+  public static FromHash(str: string): Address;
+  public static FromHash(input: Uint8Array): Address;
+  public static FromHash(input: any): Address {
+    let bytes: Uint8Array;
+    if (typeof input === 'string') {
+      bytes = new TextEncoder().encode(input);
+    } else {
+      bytes = input;
+    }
+
+    const hash = SHA256(hexEncoding.parse(uint8ArrayToString(bytes)));
+    bytes = new Uint8Array(Address.LengthInBytes);
+    bytes[0] = AddressKind.User;
+    bytes.set(hash.words.slice(0, 32), 2);
+    return new Address(bytes);
+  }
+
+  public static FromWif(wif: string): Address {
+    const privateKey = getPrivateKeyFromWif(wif);
+    const publicKey = getPublicKeyFromPrivateKey(privateKey);
+    var addressHex = Buffer.from('0100' + publicKey, 'hex');
+    return this.FromBytes(addressHex);
+  }
+
+  public compareTo(other: Address): number {
+    for (let i = 0; i < Address.LengthInBytes; i++) {
+      if (this._bytes[i] < other._bytes[i]) {
+        return -1;
+      } else if (this._bytes[i] > other._bytes[i]) {
+        return 1;
+      }
+    }
+    return 0;
+  }
+
+  public equals(other: any): boolean {
+    if (!(other instanceof Address)) {
+      return false;
+    }
+    const address = other as Address;
+    return this._bytes.toString() === address._bytes.toString();
+  }
+
+  public toString(): string {
+    if (this.IsNull) {
+      return Address.NullText;
+    }
+
+    if (!this._text) {
+      let prefix: string;
+      switch (this.Kind) {
+        case AddressKind.User:
+          prefix = 'P';
+          break;
+        case AddressKind.Interop:
+          prefix = 'X';
+          break;
+        default:
+          prefix = 'S';
+          break;
+      }
+      this._text = prefix + base58.encode(this._bytes);
+    }
+    return this._text;
+  }
+
+  public ToByteArray(): Uint8Array {
+    return this._bytes;
+  }
+
+  SerializeData(writer: PBinaryWriter) {
+    writer.writeByteArray(this._bytes);
+  }
+
+  UnserializeData(reader: PBinaryReader) {
+    this._bytes = reader.readByteArray();
+    this._text = null;
+  }
+}