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

package/src/core/tx/Transaction.ts

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

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

package/src/core/tx/utils.ts

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

@@ -1,290 +0,0 @@
-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;
-  }
-}