Refactored TransactionMapping

- createTransactionFromPayload now use catbuffer

Author: rg911

src/core/format/Convert.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { decode } from 'utf8';
 import * as utilities from './Utilities';
 
 export class Convert {
@@ -172,4 +173,21 @@ export class Convert {
         }
         return result;
     }
+
+    /**
+     * @internal decode hex to uft8 string
+     * @param hex - Hex input
+     * @returns {string}
+     */
+    public static decodeHex = (hex: string): string => {
+        let str = '';
+        for (let i = 0; i < hex.length; i += 2) {
+            str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+        }
+        try {
+            return decode(str);
+        } catch (e) {
+            return str;
+        }
+    }
 }

src/core/utils/TransactionMapping.ts

@@ -16,7 +16,9 @@
 
 import { CreateTransactionFromDTO } from '../../infrastructure/transaction/CreateTransactionFromDTO';
 import { CreateTransactionFromPayload } from '../../infrastructure/transaction/CreateTransactionFromPayload';
+import { InnerTransaction } from '../../model/transaction/InnerTransaction';
 import { Transaction } from '../../model/transaction/Transaction';
+import { SignSchema } from '../crypto/SignSchema';
 
 export class TransactionMapping {
 
@@ -31,10 +33,14 @@ export class TransactionMapping {
 
     /**
      * Create transaction class from payload binary.
-     * @param {string} dataBytes The transaction json object.
-     * @returns {module: model/transaction/transaction} The transaction class.
+     * @param {string} payload The transaction binary payload
+     * @param {Boolean} isEmbedded Is embedded transaction (Default: false)
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @returns {Transaction | InnerTransaction} The transaction class.
      */
-    public static createFromPayload(dataBytes: string): Transaction {
-        return CreateTransactionFromPayload(dataBytes);
+    public static createFromPayload(payload: string,
+                                    isEmbedded = false,
+                                    signSchema = SignSchema.SHA3): Transaction | InnerTransaction {
+        return CreateTransactionFromPayload(payload, isEmbedded, signSchema);
     }
 }

src/infrastructure/catbuffer/GeneratorUtils.ts

@@ -1,119 +1,117 @@
 // tslint:disable: jsdoc-format
 /**
-*** Copyright (c) 2016-present,
-*** Jaguar0625, gimre, BloodyRookie, Tech Bureau, Corp. All rights reserved.
-***
-*** This file is part of Catapult.
-***
-*** Catapult is free software: you can redistribute it and/or modify
-*** it under the terms of the GNU Lesser General Public License as published by
-*** the Free Software Foundation, either version 3 of the License, or
-*** (at your option) any later version.
-***
-*** Catapult is distributed in the hope that it will be useful,
-*** but WITHOUT ANY WARRANTY; without even the implied warranty of
-*** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-*** GNU Lesser General Public License for more details.
-***
-*** You should have received a copy of the GNU Lesser General Public License
-*** along with Catapult. If not, see <http://www.gnu.org/licenses/>.
-**/
+ *** Copyright (c) 2016-present,
+ *** Jaguar0625, gimre, BloodyRookie, Tech Bureau, Corp. All rights reserved.
+ ***
+ *** This file is part of Catapult.
+ ***
+ *** Catapult is free software: you can redistribute it and/or modify
+ *** it under the terms of the GNU Lesser General Public License as published by
+ *** the Free Software Foundation, either version 3 of the License, or
+ *** (at your option) any later version.
+ ***
+ *** Catapult is distributed in the hope that it will be useful,
+ *** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *** GNU Lesser General Public License for more details.
+ ***
+ *** You should have received a copy of the GNU Lesser General Public License
+ *** along with Catapult. If not, see <http://www.gnu.org/licenses/>.
+ **/
 
 /**
  * Generator utility class.
  */
 export class GeneratorUtils {
 
-	/**
+    /**
      * Converts a (64bit) uint8 array into a number array.
      * @param {Uint8Array} input A uint8 array.
      * @returns {number[]} The uint64 representation of the input.
      */
-    public static bufferToUint64 (input: Uint8Array): number[] {
+    public static bufferToUint64(input: Uint8Array): number[] {
         if (8 !== input.length) {
             throw Error(`byte array has unexpected size '${input.length}'`);
-		}
-		input = input.reverse();
-        return [GeneratorUtils.readUint32At(input, 0), GeneratorUtils.readUint32At(input, 4)];
-	}
-	
-	/**
+        }
+        input = input.reverse();
+        const view = new DataView(input.buffer);
+        return [view.getUint32(4), view.getUint32(0)];
+    }
+
+    /**
      * Read buffer into 32bits integer at given index.
      * @param {Uint8Array} bytes A uint8 array.
-	 * @param {number} index Index.
+     * @param {number} index Index.
      * @returns {number} 32bits integer.
      */
-	public static readUint32At(bytes: Uint8Array, index: number): number {
-		return (bytes[index] + (bytes[index + 1] << 8) + (bytes[index + 2] << 16) + (bytes[index + 3] << 24)) >>> 0;
-	}
+    public static readUint32At(bytes: Uint8Array, index: number): number {
+        return (bytes[index] + (bytes[index + 1] << 8) + (bytes[index + 2] << 16) + (bytes[index + 3] << 24)) >>> 0;
+    }
 
-	/**
+    /**
      * Write uint to buffer
      * @param {number} uintValue A uint8 array.
-	 * @param {number} bufferSize Buffer size.
+     * @param {number} bufferSize Buffer size.
      * @returns {Uint8Array}
      */
-	public static uintToBuffer (uintValue: number, bufferSize: number): Uint8Array {
-		const buffer = new ArrayBuffer(bufferSize);
-		const dataView = new DataView(buffer);
-		if (1 === bufferSize)
-			dataView.setUint8(0, uintValue);
-	
-		else if (2 === bufferSize)
-			dataView.setUint16(0, uintValue, true);
-	
-		else if (4 === bufferSize)
-			dataView.setUint32(0, uintValue, true);
-	
-		else
-			throw new Error('Unexpected bufferSize');
-	
-		return new Uint8Array(buffer);
-	}
+    public static uintToBuffer(uintValue: number, bufferSize: number): Uint8Array {
+        const buffer = new ArrayBuffer(bufferSize);
+        const dataView = new DataView(buffer);
+        if (1 === bufferSize) {
+            dataView.setUint8(0, uintValue);
+        } else if (2 === bufferSize) {
+            dataView.setUint16(0, uintValue, true);
+        } else if (4 === bufferSize) {
+            dataView.setUint32(0, uintValue, true);
+        } else {
+            throw new Error('Unexpected bufferSize');
+        }
+
+        return new Uint8Array(buffer);
+    }
 
-	/**
+    /**
      * Write uint to buffer
      * @param {Uint8Array} buffer A uint8 array.
      * @returns {number}
      */
-	public static bufferToUint(buffer: Uint8Array): number {
-		const dataView = new DataView(buffer.buffer);
-		if (1 === buffer.byteLength)
-			return dataView.getUint8(0);
-	
-		else if (2 === buffer.byteLength)
-			return dataView.getUint16(0, true);
-	
-		else if (4 === buffer.byteLength)
-			return dataView.getUint32(0, true);
-	
-		throw new Error('Unexpected buffer size');
-	};
+    public static bufferToUint(buffer: Uint8Array): number {
+        const dataView = new DataView(buffer.buffer);
+        if (1 === buffer.byteLength) {
+            return dataView.getUint8(0);
+        } else if (2 === buffer.byteLength) {
+            return dataView.getUint16(0, true);
+        } else if (4 === buffer.byteLength) {
+            return dataView.getUint32(0, true);
+             }
 
-	/**
+        throw new Error('Unexpected buffer size');
+    }
+
+    /**
      * Write Uint64 to buffer
      * @param {number} uintValue Uint64 (number[]).
      * @returns {Uint8Array}
      */
-	public static uint64ToBuffer(uintValue: number[]): Uint8Array {
-		const uint32Array = new Uint32Array(uintValue);
-		return new Uint8Array(uint32Array.buffer);
-	}
+    public static uint64ToBuffer(uintValue: number[]): Uint8Array {
+        const uint32Array = new Uint32Array(uintValue);
+        return new Uint8Array(uint32Array.buffer);
+    }
 
-	/**
+    /**
      * Concatenate two arrays
      * @param {Uint8Array} array1 A Uint8Array.
-	 * @param {Uint8Array} array2 A Uint8Array.
+     * @param {Uint8Array} array2 A Uint8Array.
      * @returns {Uint8Array}
      */
-	public static concatTypedArrays(array1: Uint8Array, array2: Uint8Array): Uint8Array {
-		const newArray = new Uint8Array(array1.length + array2.length);
-		newArray.set(array1);
-		newArray.set(array2, array1.length);
-		return newArray;
-	}
+    public static concatTypedArrays(array1: Uint8Array, array2: Uint8Array): Uint8Array {
+        const newArray = new Uint8Array(array1.length + array2.length);
+        newArray.set(array1);
+        newArray.set(array2, array1.length);
+        return newArray;
+    }
 
-	/** Converts an unsigned byte to a signed byte with the same binary representation.
+    /** Converts an unsigned byte to a signed byte with the same binary representation.
      * @param {number} input An unsigned byte.
      * @returns {number} A signed byte with the same binary representation as the input.
      *
@@ -125,17 +123,17 @@ export class GeneratorUtils {
         return input << 24 >> 24;
     }
 
-	/** Get bytes by given sub array size.
-	 * @param {Uint8Array} binary Binary bytes array.
+    /** Get bytes by given sub array size.
+     * @param {Uint8Array} binary Binary bytes array.
      * @param {number} size Subarray size.
-     * @returns {Uint8Array} 
+     * @returns {Uint8Array}
      *
      */
-	public static getBytes(binary: Uint8Array, size: number): Uint8Array {
-		if (size > binary.length)
-			throw new RangeError();
-
-		const bytes = binary.slice(0, size);
-		return bytes;
-	}
+    public static getBytes(binary: Uint8Array, size: number): Uint8Array {
+        if (size > binary.length) {
+            throw new RangeError();
+        }
+        const bytes = binary.slice(0, size);
+        return bytes;
+    }
 }