From aff8179f13ff5a630a65dc1a78cf5704ead81325 Mon Sep 17 00:00:00 2001 From: Steven Liu Date: Tue, 11 Jun 2019 19:41:47 +0100 Subject: [PATCH 1/7] Added #93 Merged encoders from Lib into SDK --- e2e/infrastructure/TransactionHttp.spec.ts | 3 +- index.ts | 1 + src/core/format/Base32.ts | 52 +++ src/core/format/Convert.ts | 175 +++++++++ src/core/format/IdGenerator.ts | 53 +++ src/core/format/RawAddress.ts | 130 +++++++ src/core/format/RawArray.ts | 84 +++++ src/core/format/RawUInt64.ts | 116 ++++++ src/core/format/Utilities.ts | 181 +++++++++ src/core/format/index.ts | 21 ++ src/infrastructure/NamespaceHttp.ts | 3 +- .../transaction/CreateTransactionFromDTO.ts | 5 +- .../CreateTransactionFromPayload.ts | 2 +- src/model/UInt64.ts | 2 +- src/model/account/Account.ts | 3 +- src/model/account/Address.ts | 2 +- src/model/account/PublicAccount.ts | 3 +- src/model/mosaic/MosaicId.ts | 5 +- src/model/mosaic/MosaicNonce.ts | 3 +- src/model/mosaic/NetworkHarvestMosaic.ts | 3 - src/model/namespace/AddressAlias.ts | 1 - src/model/namespace/Alias.ts | 4 - src/model/namespace/EmptyAlias.ts | 2 - src/model/namespace/MosaicAlias.ts | 1 - src/model/namespace/NamespaceId.ts | 3 +- src/model/transaction/AliasTransaction.ts | 5 - src/model/transaction/HashType.ts | 2 +- .../RegisterNamespaceTransaction.ts | 3 +- .../transaction/SecretLockTransaction.ts | 3 +- .../transaction/SecretProofTransaction.ts | 3 +- src/model/transaction/TransferTransaction.ts | 3 +- src/model/wallet/SimpleWallet.ts | 3 +- test/core/format/Base32.spec.ts | 188 ++++++++++ test/core/format/Convert.spec.ts | 352 ++++++++++++++++++ test/core/format/IdGenerator.spec.ts | 251 +++++++++++++ test/core/format/RawAddress.spec.ts | 216 +++++++++++ test/core/format/RawArray.spec.ts | 223 +++++++++++ test/core/format/RawUInt64.spec.ts | 319 ++++++++++++++++ test/core/format/Utilities.spec.ts | 146 ++++++++ test/core/utils/TransactionMapping.spec.ts | 2 +- .../SerializeTransactionToJSON.spec.ts | 2 +- .../transaction/SecretLockTransaction.spec.ts | 2 +- .../SecretProofTransaction.spec.ts | 2 +- 43 files changed, 2541 insertions(+), 42 deletions(-) create mode 100644 src/core/format/Base32.ts create mode 100644 src/core/format/Convert.ts create mode 100644 src/core/format/IdGenerator.ts create mode 100644 src/core/format/RawAddress.ts create mode 100644 src/core/format/RawArray.ts create mode 100644 src/core/format/RawUInt64.ts create mode 100644 src/core/format/Utilities.ts create mode 100644 src/core/format/index.ts create mode 100644 test/core/format/Base32.spec.ts create mode 100644 test/core/format/Convert.spec.ts create mode 100644 test/core/format/IdGenerator.spec.ts create mode 100644 test/core/format/RawAddress.spec.ts create mode 100644 test/core/format/RawArray.spec.ts create mode 100644 test/core/format/RawUInt64.spec.ts create mode 100644 test/core/format/Utilities.spec.ts diff --git a/e2e/infrastructure/TransactionHttp.spec.ts b/e2e/infrastructure/TransactionHttp.spec.ts index c94cca7fdc..f27931a440 100644 --- a/e2e/infrastructure/TransactionHttp.spec.ts +++ b/e2e/infrastructure/TransactionHttp.spec.ts @@ -17,7 +17,8 @@ import {assert, expect} from 'chai'; import * as CryptoJS from 'crypto-js'; import {ChronoUnit} from 'js-joda'; import {keccak_256, sha3_256} from 'js-sha3'; -import {convert, nacl_catapult} from 'nem2-library'; +import {nacl_catapult} from 'nem2-library'; +import { Convert as convert } from '../../src/core/format'; import {AccountHttp} from '../../src/infrastructure/AccountHttp'; import { NamespaceHttp } from '../../src/infrastructure/infrastructure'; import {Listener} from '../../src/infrastructure/Listener'; diff --git a/index.ts b/index.ts index 7c61994968..1146495f42 100644 --- a/index.ts +++ b/index.ts @@ -18,3 +18,4 @@ export * from './src/infrastructure/infrastructure'; export * from './src/model/model'; export * from './src/service/service'; export * from './src/core/utils/utility'; +export * from './src/core/format'; diff --git a/src/core/format/Base32.ts b/src/core/format/Base32.ts new file mode 100644 index 0000000000..ac5314f457 --- /dev/null +++ b/src/core/format/Base32.ts @@ -0,0 +1,52 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as utilities from './Utilities'; + +export class Base32 { + /** + * Base32 encodes a binary buffer. + * @param {Uint8Array} data The binary data to encode. + * @returns {string} The base32 encoded string corresponding to the input data. + */ + public static Base32Encode = (data: Uint8Array): string => { + if (0 !== data.length % utilities.Decoded_Block_Size) { + throw Error(`decoded size must be multiple of ${utilities.Decoded_Block_Size}`); + } + const output = new Array(data.length / utilities.Decoded_Block_Size * utilities.Encoded_Block_Size); + for (let i = 0; i < data.length / utilities.Decoded_Block_Size; ++i) { + utilities.encodeBlock(data, i * utilities.Decoded_Block_Size, output, i * utilities.Encoded_Block_Size); + } + return output.join(''); + } + + /** + * Base32 decodes a base32 encoded string. + * @param {string} encoded The base32 encoded string to decode. + * @returns {Uint8Array} The binary data corresponding to the input string. + */ + public static Base32Decode = (encoded: string): Uint8Array => { + if (0 !== encoded.length % utilities.Encoded_Block_Size) { + throw Error(`encoded size must be multiple of ${utilities.Encoded_Block_Size}`); + } + + const output = new Uint8Array(encoded.length / utilities.Encoded_Block_Size * utilities.Decoded_Block_Size); + for (let i = 0; i < encoded.length / utilities.Encoded_Block_Size; ++i) { + utilities.decodeBlock(encoded, i * utilities.Encoded_Block_Size, output, i * utilities.Decoded_Block_Size); + } + return output; + } +} diff --git a/src/core/format/Convert.ts b/src/core/format/Convert.ts new file mode 100644 index 0000000000..f6d12097b2 --- /dev/null +++ b/src/core/format/Convert.ts @@ -0,0 +1,175 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import * as utilities from './Utilities'; + +export class Convert { + + /** + * Decodes two hex characters into a byte. + * @param {string} char1 The first hex digit. + * @param {string} char2 The second hex digit. + * @returns {number} The decoded byte. + */ + public static toByte = (char1: string, char2: string): number => { + const byte = utilities.tryParseByte(char1, char2); + if (undefined === byte) { + throw Error(`unrecognized hex char`); + } + return byte; + } + + /** + * Determines whether or not a string is a hex string. + * @param {string} input The string to test. + * @returns {boolean} true if the input is a hex string, false otherwise. + */ + public static isHexString = (input: string): boolean => { + if (0 !== input.length % 2) { + return false; + } + for (let i = 0; i < input.length; i += 2) { + if (undefined === utilities.tryParseByte(input[i], input[i + 1])) { + return false; + } + } + return true; + } + + /** + * Converts a hex string to a uint8 array. + * @param {string} input A hex encoded string. + * @returns {Uint8Array} A uint8 array corresponding to the input. + */ + public static hexToUint8 = (input: string): Uint8Array => { + if (0 !== input.length % 2) { + throw Error(`hex string has unexpected size '${input.length}'`); + } + const output = new Uint8Array(input.length / 2); + for (let i = 0; i < input.length; i += 2) { + output[i / 2] = Convert.toByte(input[i], input[i + 1]); + } + return output; + } + + /** + * Reversed convertion hex string to a uint8 array. + * @param {string} input A hex encoded string. + * @returns {Uint8Array} A uint8 array corresponding to the input. + */ + public static hexToUint8Reverse = (input: string): Uint8Array => { + if (0 !== input.length % 2) { + throw Error(`hex string has unexpected size '${input.length}'`); + } + const output = new Uint8Array(input.length / 2); + for (let i = 0; i < input.length; i += 2) { + output[output.length - 1 - (i / 2)] = Convert.toByte(input[i], input[i + 1]); + } + return output; + } + + /** + * Converts a uint8 array to a hex string. + * @param {Uint8Array} input A uint8 array. + * @returns {string} A hex encoded string corresponding to the input. + */ + public static uint8ToHex = (input) => { + let s = ''; + for (const byte of input) { + s += utilities.Nibble_To_Char_Map[byte >> 4]; + s += utilities.Nibble_To_Char_Map[byte & 0x0F]; + } + + return s; + } + + /** + * Converts a uint8 array to a uint32 array. + * @param {Uint8Array} input A uint8 array. + * @returns {Uint32Array} A uint32 array created from the input. + */ + public static uint8ToUint32 = (input) => new Uint32Array(input.buffer); + + /** + * Converts a uint32 array to a uint8 array. + * @param {Uint32Array} input A uint32 array. + * @returns {Uint8Array} A uint8 array created from the input. + */ + public static uint32ToUint8 = (input: Uint32Array): Uint8Array => new Uint8Array(input.buffer); + + /** 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. + * + */ + public static uint8ToInt8 = (input: number): number => { + if (0xFF < input) { + throw Error(`input '${input}' is out of range`); + } + return input << 24 >> 24; + } + + /** Converts a signed byte to an unsigned byte with the same binary representation. + * @param {number} input A signed byte. + * @returns {number} An unsigned byte with the same binary representation as the input. + */ + public static int8ToUint8 = (input: number): number => { + if (127 < input || -128 > input) { + throw Error(`input '${input}' is out of range`); + } + return input & 0xFF; + } + + /** + * Converts a raw javascript string into a string of single byte characters using utf8 encoding. + * This makes it easier to perform other encoding operations on the string. + * @param {string} input - A raw string + * @return {string} - UTF-8 string + */ + public static rstr2utf8 = (input: string): string => { + let output = ''; + + for (let n = 0; n < input.length; n++) { + const c = input.charCodeAt(n); + + if (128 > c) { + output += String.fromCharCode(c); + } else if ((127 < c) && (2048 > c)) { + output += String.fromCharCode((c >> 6) | 192); + output += String.fromCharCode((c & 63) | 128); + } else { + output += String.fromCharCode((c >> 12) | 224); + output += String.fromCharCode(((c >> 6) & 63) | 128); + output += String.fromCharCode((c & 63) | 128); + } + } + + return output; + } + + /** + * Convert UTF-8 to hex + * @param {string} input - An UTF-8 string + * @return {string} + */ + public static utf8ToHex = (input: string): string => { + const rawString = Convert.rstr2utf8(input); + let result = ''; + for (let i = 0; i < rawString.length; i++) { + result += rawString.charCodeAt(i).toString(16); + } + return result; + } +} diff --git a/src/core/format/IdGenerator.ts b/src/core/format/IdGenerator.ts new file mode 100644 index 0000000000..e0ab0967b3 --- /dev/null +++ b/src/core/format/IdGenerator.ts @@ -0,0 +1,53 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {sha3_256} from 'js-sha3'; +import * as utilities from './Utilities'; + +export class IdGenerator { + /** + * Generates a mosaic id given a nonce and a public id. + * @param {object} nonce The mosaic nonce. + * @param {object} ownerPublicId The public id. + * @returns {module:coders/uint64~uint64} The mosaic id. + */ + public static generateMosaicId = (nonce, ownerPublicId) => { + const hash = sha3_256.create(); + hash.update(nonce); + hash.update(ownerPublicId); + const result = new Uint32Array(hash.arrayBuffer()); + return [result[0], result[1] & 0x7FFFFFFF]; + } + + /** + * Parses a unified namespace name into a path. + * @param {string} name The unified namespace name. + * @returns {array} The namespace path. + */ + public static generateNamespacePath = (name: string) => { + if (0 >= name.length) { + utilities.throwInvalidFqn('having zero length', name); + } + let namespaceId = utilities.idGeneratorConst.namespace_base_id; + const path = []; + const start = utilities.split(name, (substringStart, size) => { + namespaceId = utilities.generateNamespaceId(namespaceId, utilities.extractPartName(name, substringStart, size)); + utilities.append(path, namespaceId, name); + }); + namespaceId = utilities.generateNamespaceId(namespaceId, utilities.extractPartName(name, start, name.length - start)); + utilities.append(path, namespaceId, name); + return path; + } +} diff --git a/src/core/format/RawAddress.ts b/src/core/format/RawAddress.ts new file mode 100644 index 0000000000..c512e3a4f4 --- /dev/null +++ b/src/core/format/RawAddress.ts @@ -0,0 +1,130 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { sha3_256 } from 'js-sha3'; +import RIPEMD160 = require('ripemd160'); +import { Base32 } from './Base32'; +import { Convert } from './Convert'; +import { RawArray } from './RawArray'; + +export class RawAddress { + static readonly constants = { + sizes: { + ripemd160: 20, + addressDecoded: 25, + addressEncoded: 40, + key: 32, + checksum: 4, + }, + }; + /** + * Converts an encoded address string to a decoded address. + * @param {string} encoded The encoded address string. + * @returns {Uint8Array} The decoded address corresponding to the input. + */ + public static stringToAddress = (encoded: string): Uint8Array => { + if (RawAddress.constants.sizes.addressEncoded !== encoded.length) { + throw Error(`${encoded} does not represent a valid encoded address`); + } + + return Base32.Base32Decode(encoded); + } + + /** + * Format a namespaceId *alias* into a valid recipient field value. + * @param {Uint8Array} namespaceId The namespaceId + * @returns {Uint8Array} The padded notation of the alias + */ + public static aliasToRecipient = (namespaceId: Uint8Array): Uint8Array => { + // 0x91 | namespaceId on 8 bytes | 16 bytes 0-pad = 25 bytes + const padded = new Uint8Array(1 + 8 + 16); + padded.set([0x91], 0); + padded.set(namespaceId.reverse(), 1); + padded.set(Convert.hexToUint8('00'.repeat(16)), 9); + return padded; + } + + /** + * Converts a decoded address to an encoded address string. + * @param {Uint8Array} decoded The decoded address. + * @returns {string} The encoded address string corresponding to the input. + */ + public static addressToString = (decoded: Uint8Array): string => { + if (RawAddress.constants.sizes.addressDecoded !== decoded.length) { + throw Error(`${Convert.uint8ToHex(decoded)} does not represent a valid decoded address`); + } + + return Base32.Base32Encode(decoded); + } + + /** + * Converts a public key to a decoded address for a specific network. + * @param {Uint8Array} publicKey The public key. + * @param {number} networkIdentifier The network identifier. + * @returns {Uint8Array} The decoded address corresponding to the inputs. + */ + public static publicKeyToAddress = (publicKey: Uint8Array, networkIdentifier: number): Uint8Array => { + // step 1: sha3 hash of the public key + const publicKeyHash = (sha3_256 as any).arrayBuffer(publicKey); + + // step 2: ripemd160 hash of (1) + const ripemdHash = new RIPEMD160().update(new Buffer(publicKeyHash)).digest(); + + // step 3: add network identifier byte in front of (2) + const decodedAddress = new Uint8Array(RawAddress.constants.sizes.addressDecoded); + decodedAddress[0] = networkIdentifier; + RawArray.copy(decodedAddress, ripemdHash, RawAddress.constants.sizes.ripemd160, 1); + + // step 4: concatenate (3) and the checksum of (3) + const hash = (sha3_256 as any).arrayBuffer(decodedAddress.subarray(0, RawAddress.constants.sizes.ripemd160 + 1)); + RawArray.copy(decodedAddress, RawArray.uint8View(hash), + RawAddress.constants.sizes.checksum, RawAddress.constants.sizes.ripemd160 + 1); + + return decodedAddress; + } + + /** + * Determines the validity of a decoded address. + * @param {Uint8Array} decoded The decoded address. + * @returns {boolean} true if the decoded address is valid, false otherwise. + */ + public static isValidAddress = (decoded: Uint8Array): boolean => { + const hash = sha3_256.create(); + const checksumBegin = RawAddress.constants.sizes.addressDecoded - RawAddress.constants.sizes.checksum; + hash.update(decoded.subarray(0, checksumBegin)); + const checksum = new Uint8Array(RawAddress.constants.sizes.checksum); + RawArray.copy(checksum, RawArray.uint8View(hash.arrayBuffer()), RawAddress.constants.sizes.checksum); + return RawArray.deepEqual(checksum, decoded.subarray(checksumBegin)); + } + + /** + * Determines the validity of an encoded address string. + * @param {string} encoded The encoded address string. + * @returns {boolean} true if the encoded address string is valid, false otherwise. + */ + public static isValidEncodedAddress = (encoded: string): boolean => { + if (RawAddress.constants.sizes.addressEncoded !== encoded.length) { + return false; + } + + try { + const decoded = RawAddress.stringToAddress(encoded); + return RawAddress.isValidAddress(decoded); + } catch (err) { + return false; + } + } +} diff --git a/src/core/format/RawArray.ts b/src/core/format/RawArray.ts new file mode 100644 index 0000000000..d1c0bdad81 --- /dev/null +++ b/src/core/format/RawArray.ts @@ -0,0 +1,84 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export class RawArray { + /** + * Creates a Uint8Array view on top of input. + * @param {ArrayBuffer|Uint8Array} input The input array. + * @returns {Uint8Array} A Uint8Array view on top of input. + */ + public static uint8View = (input) => { + if (ArrayBuffer === input.constructor) { + return new Uint8Array(input); + } else if (Uint8Array === input.constructor) { + return input; + } + + throw Error('unsupported type passed to uint8View'); + } + + /** + * Copies elements from a source array to a destination array. + * @param {Array} dest The destination array. + * @param {Array} src The source array. + * @param {number} [numElementsToCopy=undefined] The number of elements to copy. + * @param {number} [destOffset=0] The first index of the destination to write. + * @param {number} [srcOffset=0] The first index of the source to read. + */ + public static copy = (dest, src, numElementsToCopy?, destOffset = 0, srcOffset = 0) => { + const length = undefined === numElementsToCopy ? dest.length : numElementsToCopy; + for (let i = 0; i < length; ++i) { + dest[destOffset + i] = src[srcOffset + i]; + } + } + + /** + * Determines whether or not an array is zero-filled. + * @param {Array} array The array to check. + * @returns {boolean} true if the array is zero-filled, false otherwise. + */ + public static isZeroFilled = (array) => array.every(value => 0 === value); + + /** + * Deeply checks the equality of two arrays. + * @param {Array} lhs First array to compare. + * @param {Array} rhs Second array to compare. + * @param {number} [numElementsToCompare=undefined] The number of elements to compare. + * @returns {boolean} true if all compared elements are equal, false otherwise. + */ + public static deepEqual = (lhs, rhs, numElementsToCompare?) => { + let length = numElementsToCompare; + if (undefined === length) { + if (lhs.length !== rhs.length) { + return false; + } + + length = lhs.length; + } + + if (length > lhs.length || length > rhs.length) { + return false; + } + + for (let i = 0; i < length; ++i) { + if (lhs[i] !== rhs[i]) { + return false; + } + } + + return true; + } +} diff --git a/src/core/format/RawUInt64.ts b/src/core/format/RawUInt64.ts new file mode 100644 index 0000000000..81eaf3bf1e --- /dev/null +++ b/src/core/format/RawUInt64.ts @@ -0,0 +1,116 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { Convert } from './Convert'; + +export class RawUInt64 { + static readonly readUint32At = (bytes, i) => (bytes[i] + (bytes[i + 1] << 8) + (bytes[i + 2] << 16) + (bytes[i + 3] << 24)) >>> 0; + + /** + * An exact uint64 representation composed of two 32bit values. + * @typedef {Array} uint64 + * @property {number} 0 The low 32bit value. + * @property {number} 1 The high 32bit value. + */ + /** + * Tries to compact a uint64 into a simple numeric. + * @param {module:coders/uint64~uint64} uint64 A uint64 value. + * @returns {number|module:coders/uint64~uint64} + * A numeric if the uint64 is no greater than Number.MAX_SAFE_INTEGER or the original uint64 value otherwise. + */ + public static compact = (uint64) => { + const low = uint64[0]; + const high = uint64[1]; + + // don't compact if the value is >= 2^53 + if (0x00200000 <= high) { + return uint64; + } + + // multiply because javascript bit operations operate on 32bit values + return (high * 0x100000000) + low; + } + + /** + * Converts a numeric unsigned integer into a uint64. + * @param {number} number The unsigned integer. + * @returns {module:coders/uint64~uint64} The uint64 representation of the input. + */ + public static fromUint = (number) => { + const value = [(number & 0xFFFFFFFF) >>> 0, (number / 0x100000000) >>> 0]; + return value; + } + + /** + * Converts a (64bit) uint8 array into a uint64. + * @param {Uint8Array} uint8Array A uint8 array. + * @returns {module:coders/uint64~uint64} The uint64 representation of the input. + */ + public static fromBytes = (uint8Array) => { + if (8 !== uint8Array.length) { + throw Error(`byte array has unexpected size '${uint8Array.length}'`); + } + return [RawUInt64.readUint32At(uint8Array, 0), RawUInt64.readUint32At(uint8Array, 4)]; + } + + /** + * Converts a (32bit) uint8 array into a uint64. + * @param {Uint8Array} uint8Array A uint8 array. + * @returns {module:coders/uint64~uint64} The uint64 representation of the input. + */ + public static fromBytes32 = (uint8Array) => { + if (4 !== uint8Array.length) { + throw Error(`byte array has unexpected size '${uint8Array.length}'`); + } + return [RawUInt64.readUint32At(uint8Array, 0), 0]; + } + + /** + * Parses a hex string into a uint64. + * @param {string} input A hex encoded string. + * @returns {module:coders/uint64~uint64} The uint64 representation of the input. + */ + public static fromHex = (input) => { + if (16 !== input.length) { + throw Error(`hex string has unexpected size '${input.length}'`); + } + let hexString = input; + if (16 > hexString.length) { + hexString = '0'.repeat(16 - hexString.length) + hexString; + } + const uint8Array = Convert.hexToUint8(hexString); + const view = new DataView(uint8Array.buffer); + return [view.getUint32(4), view.getUint32(0)]; + } + + /** + * Converts a uint64 into a hex string. + * @param {module:coders/uint64~uint64} uint64 A uint64 value. + * @returns {string} A hex encoded string representing the uint64. + */ + public static toHex = (uint64) => { + const uint32Array = new Uint32Array(uint64); + const uint8Array = Convert.uint32ToUint8(uint32Array).reverse(); + return Convert.uint8ToHex(uint8Array); + } + + /** + * Returns true if a uint64 is zero. + * @param {module:coders/uint64~uint64} uint64 A uint64 value. + * @returns {boolean} true if the value is zero. + */ + public static isZero = (uint64) => 0 === uint64[0] && 0 === uint64[1]; +} diff --git a/src/core/format/Utilities.ts b/src/core/format/Utilities.ts new file mode 100644 index 0000000000..fe0fc1b401 --- /dev/null +++ b/src/core/format/Utilities.ts @@ -0,0 +1,181 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {sha3_256} from 'js-sha3'; + +export const createBuilder = () => { + const map = {}; + return { + map, + /** + * Adds a range mapping to the map. + * @param {string} start The start character. + * @param {string} end The end character. + * @param {number} base The value corresponding to the start character. + * @memberof module:utils/charMapping~CharacterMapBuilder + * @instance + */ + addRange: (start, end, base) => { + const startCode = start.charCodeAt(0); + const endCode = end.charCodeAt(0); + + for (let code = startCode; code <= endCode; ++code) { + map[String.fromCharCode(code)] = code - startCode + base; + } + }, + }; +}; + +const Char_To_Nibble_Map = () => { + const builder = createBuilder(); + builder.addRange('0', '9', 0); + builder.addRange('a', 'f', 10); + builder.addRange('A', 'F', 10); + return builder.map; +}; + +const Char_To_Digit_Map = () => { + const builder = createBuilder(); + builder.addRange('0', '9', 0); + return builder.map; +}; + +export const Nibble_To_Char_Map = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']; +export const Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'; +export const Decoded_Block_Size = 5; +export const Encoded_Block_Size = 8; +export const tryParseByte = (char1, char2) => { + const charMap = Char_To_Nibble_Map(); + const nibble1 = charMap[char1]; + const nibble2 = charMap[char2]; + return undefined === nibble1 || undefined === nibble2 ? + undefined : + (nibble1 << 4) | nibble2; +}; + +/** + * Tries to parse a string representing an unsigned integer. + * @param {string} str The string to parse. + * @returns {number} The number represented by the input or undefined. + */ +export const tryParseUint = (str) => { + if ('0' === str) { + return 0; + } + let value = 0; + for (const char of str) { + const charMap = Char_To_Digit_Map(); + const digit = charMap[char]; + if (undefined === digit || (0 === value && 0 === digit)) { + return undefined; + } + + value *= 10; + value += digit; + + if (value > Number.MAX_SAFE_INTEGER) { + return undefined; + } + } + return value; +}; + +export const idGeneratorConst = { + namespace_base_id: [0, 0], + namespace_max_depth: 3, + name_pattern: /^[a-z0-9][a-z0-9-_]*$/, +}; + +export const throwInvalidFqn = (reason, name) => { + throw Error(`fully qualified id is invalid due to ${reason} (${name})`); +}; + +export const extractPartName = (name, start, size) => { + if (0 === size) { + this.throwInvalidFqn('empty part', name); + } + const partName = name.substr(start, size); + if (!idGeneratorConst.name_pattern.test(partName)) { + this.throwInvalidFqn(`invalid part name [${partName}]`, name); + } + return partName; +}; + +export const append = (path, id, name) => { + if (idGeneratorConst.namespace_max_depth === path.length) { + this.throwInvalidFqn('too many parts', name); + } + path.push(id); +}; + +export const split = (name, processor) => { + let start = 0; + for (let index = 0; index < name.length; ++index) { + if ('.' === name[index]) { + processor(start, index - start); + start = index + 1; + } + } + return start; +}; + +export const generateNamespaceId = (parentId, name) => { + const hash = sha3_256.create(); + hash.update(Uint32Array.from(parentId).buffer); + hash.update(name); + const result = new Uint32Array(hash.arrayBuffer()); + // right zero-filling required to keep unsigned number representation + return [result[0], (result[1] | 0x80000000) >>> 0]; +}; + +export const encodeBlock = (input, inputOffset, output, outputOffset) => { + output[outputOffset + 0] = Alphabet[input[inputOffset + 0] >> 3]; + output[outputOffset + 1] = Alphabet[((input[inputOffset + 0] & 0x07) << 2) | (input[inputOffset + 1] >> 6)]; + output[outputOffset + 2] = Alphabet[(input[inputOffset + 1] & 0x3E) >> 1]; + output[outputOffset + 3] = Alphabet[((input[inputOffset + 1] & 0x01) << 4) | (input[inputOffset + 2] >> 4)]; + output[outputOffset + 4] = Alphabet[((input[inputOffset + 2] & 0x0F) << 1) | (input[inputOffset + 3] >> 7)]; + output[outputOffset + 5] = Alphabet[(input[inputOffset + 3] & 0x7F) >> 2]; + output[outputOffset + 6] = Alphabet[((input[inputOffset + 3] & 0x03) << 3) | (input[inputOffset + 4] >> 5)]; + output[outputOffset + 7] = Alphabet[input[inputOffset + 4] & 0x1F]; +}; + +export const Char_To_Decoded_Char_Map = () => { + const builder = this.createBuilder(); + builder.addRange('A', 'Z', 0); + builder.addRange('2', '7', 26); + return builder.map; +}; + +export const decodeChar = (c) => { + const charMap = Char_To_Decoded_Char_Map(); + const decodedChar = charMap[c]; + if (undefined !== decodedChar) { + return decodedChar; + } + throw Error(`illegal base32 character ${c}`); +}; + +export const decodeBlock = (input, inputOffset, output, outputOffset) => { + const bytes = new Uint8Array(this.Encoded_Block_Size); + for (let i = 0; i < this.Encoded_Block_Size; ++i) { + bytes[i] = decodeChar(input[inputOffset + i]); + } + + output[outputOffset + 0] = (bytes[0] << 3) | (bytes[1] >> 2); + output[outputOffset + 1] = ((bytes[1] & 0x03) << 6) | (bytes[2] << 1) | (bytes[3] >> 4); + output[outputOffset + 2] = ((bytes[3] & 0x0F) << 4) | (bytes[4] >> 1); + output[outputOffset + 3] = ((bytes[4] & 0x01) << 7) | (bytes[5] << 2) | (bytes[6] >> 3); + output[outputOffset + 4] = ((bytes[6] & 0x07) << 5) | bytes[7]; +}; diff --git a/src/core/format/index.ts b/src/core/format/index.ts new file mode 100644 index 0000000000..27fc8ea316 --- /dev/null +++ b/src/core/format/index.ts @@ -0,0 +1,21 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export * from './RawAddress'; +export * from './RawArray'; +export * from './Convert'; +export * from './IdGenerator'; +export * from './RawUInt64'; diff --git a/src/infrastructure/NamespaceHttp.ts b/src/infrastructure/NamespaceHttp.ts index 72db046c81..e741b61b70 100644 --- a/src/infrastructure/NamespaceHttp.ts +++ b/src/infrastructure/NamespaceHttp.ts @@ -13,9 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {address as AddressLibrary, convert, NamespaceRoutesApi} from 'nem2-library'; +import {NamespaceRoutesApi} from 'nem2-library'; import {from as observableFrom, Observable} from 'rxjs'; import {map, mergeMap} from 'rxjs/operators'; +import {Convert as convert, RawAddress as AddressLibrary} from '../core/format'; import {Address} from '../model/account/Address'; import {PublicAccount} from '../model/account/PublicAccount'; import {MosaicId} from '../model/mosaic/MosaicId'; diff --git a/src/infrastructure/transaction/CreateTransactionFromDTO.ts b/src/infrastructure/transaction/CreateTransactionFromDTO.ts index df00cf8223..05ce4c157c 100644 --- a/src/infrastructure/transaction/CreateTransactionFromDTO.ts +++ b/src/infrastructure/transaction/CreateTransactionFromDTO.ts @@ -13,8 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {convert} from 'nem2-library'; -import {uint64 as UInt64Library} from 'nem2-library'; +import {Convert as convert} from '../../core/format'; +import {RawUInt64 as UInt64Library} from '../../core/format'; import {Address} from '../../model/account/Address'; import {PublicAccount} from '../../model/account/PublicAccount'; import {NetworkType} from '../../model/blockchain/NetworkType'; @@ -52,6 +52,7 @@ import {TransactionInfo} from '../../model/transaction/TransactionInfo'; import {TransactionType} from '../../model/transaction/TransactionType'; import {TransferTransaction} from '../../model/transaction/TransferTransaction'; import {UInt64} from '../../model/UInt64'; +import { RawUInt64 } from '../../core/format/RawUInt64'; /** * @internal diff --git a/src/infrastructure/transaction/CreateTransactionFromPayload.ts b/src/infrastructure/transaction/CreateTransactionFromPayload.ts index 52acb8144d..c042e778e7 100644 --- a/src/infrastructure/transaction/CreateTransactionFromPayload.ts +++ b/src/infrastructure/transaction/CreateTransactionFromPayload.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import { convert } from 'nem2-library'; +import { Convert as convert } from '../../core/format'; import {decode} from 'utf8'; import { Address } from '../../model/account/Address'; import { PublicAccount } from '../../model/account/PublicAccount'; diff --git a/src/model/UInt64.ts b/src/model/UInt64.ts index 978eec992e..61048f0170 100644 --- a/src/model/UInt64.ts +++ b/src/model/UInt64.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import {uint64} from 'nem2-library'; +import { RawUInt64 as uint64 } from '../core/format'; /** * UInt64 data model diff --git a/src/model/account/Account.ts b/src/model/account/Account.ts index 728dfc12a7..e94f7ec420 100644 --- a/src/model/account/Account.ts +++ b/src/model/account/Account.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import {address as AddressLibrary, convert, KeyPair, nacl_catapult} from 'nem2-library'; +import {KeyPair, nacl_catapult} from 'nem2-library'; +import {Convert as convert, RawAddress as AddressLibrary} from '../../core/format'; import {NetworkType} from '../blockchain/NetworkType'; import {AggregateTransaction} from '../transaction/AggregateTransaction'; import {CosignatureSignedTransaction} from '../transaction/CosignatureSignedTransaction'; diff --git a/src/model/account/Address.ts b/src/model/account/Address.ts index db5ebeeac2..b3d7dbbc40 100644 --- a/src/model/account/Address.ts +++ b/src/model/account/Address.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import {address as AddressLibrary, convert} from 'nem2-library'; +import { Convert as convert, RawAddress as AddressLibrary} from '../../core/format'; import {NetworkType} from '../blockchain/NetworkType'; /** diff --git a/src/model/account/PublicAccount.ts b/src/model/account/PublicAccount.ts index 8bc2967bcd..06b169e58e 100644 --- a/src/model/account/PublicAccount.ts +++ b/src/model/account/PublicAccount.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import { convert, KeyPair } from 'nem2-library'; +import { KeyPair } from 'nem2-library'; +import { Convert as convert} from '../../core/format'; import { NetworkType } from '../blockchain/NetworkType'; import { Address } from './Address'; diff --git a/src/model/mosaic/MosaicId.ts b/src/model/mosaic/MosaicId.ts index 42c0de97ee..3dc4db31bc 100644 --- a/src/model/mosaic/MosaicId.ts +++ b/src/model/mosaic/MosaicId.ts @@ -14,12 +14,9 @@ * limitations under the License. */ import { - convert, mosaicId as MosaicIdentifierGenerator, - nacl_catapult, - uint64 as uint64_t, } from 'nem2-library'; - +import { Convert as convert, RawUInt64 as uint64_t } from '../../core/format'; import {PublicAccount} from '../account/PublicAccount'; import {Id} from '../Id'; import {MosaicNonce} from '../mosaic/MosaicNonce'; diff --git a/src/model/mosaic/MosaicNonce.ts b/src/model/mosaic/MosaicNonce.ts index 319bf2a0eb..00985bd81a 100644 --- a/src/model/mosaic/MosaicNonce.ts +++ b/src/model/mosaic/MosaicNonce.ts @@ -14,10 +14,9 @@ * limitations under the License. */ import { - convert, nacl_catapult, } from 'nem2-library'; - +import { Convert as convert} from '../../core/format'; /** * The mosaic nonce structure * diff --git a/src/model/mosaic/NetworkHarvestMosaic.ts b/src/model/mosaic/NetworkHarvestMosaic.ts index d8f4359fb2..f9df23fb98 100644 --- a/src/model/mosaic/NetworkHarvestMosaic.ts +++ b/src/model/mosaic/NetworkHarvestMosaic.ts @@ -13,9 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -import {convert, mosaicId as MosaicIdGenerator} from 'nem2-library'; -import {PublicAccount} from '../account/PublicAccount'; import {NamespaceId} from '../namespace/NamespaceId'; import {UInt64} from '../UInt64'; import {Mosaic} from './Mosaic'; diff --git a/src/model/namespace/AddressAlias.ts b/src/model/namespace/AddressAlias.ts index 5e5c091513..de1aade68c 100644 --- a/src/model/namespace/AddressAlias.ts +++ b/src/model/namespace/AddressAlias.ts @@ -13,7 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {namespaceId as NamespaceIdGenerator} from 'nem2-library'; import {Address} from '../account/Address'; import {Alias} from './Alias'; diff --git a/src/model/namespace/Alias.ts b/src/model/namespace/Alias.ts index 5f2e56b179..b05262610a 100644 --- a/src/model/namespace/Alias.ts +++ b/src/model/namespace/Alias.ts @@ -13,12 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {namespaceId as NamespaceIdGenerator} from 'nem2-library'; import {Address} from '../account/Address'; import {MosaicId} from '../mosaic/MosaicId'; -import {AddressAlias} from './AddressAlias'; -import {AliasType} from './AliasType'; -import {MosaicAlias} from './MosaicAlias'; /** * The alias structure defines an interface for Aliases diff --git a/src/model/namespace/EmptyAlias.ts b/src/model/namespace/EmptyAlias.ts index ace9a03254..35e625f63e 100644 --- a/src/model/namespace/EmptyAlias.ts +++ b/src/model/namespace/EmptyAlias.ts @@ -13,8 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {namespaceId as NamespaceIdGenerator} from 'nem2-library'; -import {Address} from '../account/Address'; import {Alias} from './Alias'; /** diff --git a/src/model/namespace/MosaicAlias.ts b/src/model/namespace/MosaicAlias.ts index fa8048ad04..c49640016c 100644 --- a/src/model/namespace/MosaicAlias.ts +++ b/src/model/namespace/MosaicAlias.ts @@ -13,7 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {namespaceId as NamespaceIdGenerator} from 'nem2-library'; import {MosaicId} from '../mosaic/MosaicId'; import {Alias} from './Alias'; diff --git a/src/model/namespace/NamespaceId.ts b/src/model/namespace/NamespaceId.ts index 4b8f956cba..40f5316d34 100644 --- a/src/model/namespace/NamespaceId.ts +++ b/src/model/namespace/NamespaceId.ts @@ -13,7 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import {convert, namespaceId as NamespaceIdGenerator} from 'nem2-library'; +import {namespaceId as NamespaceIdGenerator} from 'nem2-library'; +import {Convert as convert} from '../../core/format'; import {Id} from '../Id'; /** diff --git a/src/model/transaction/AliasTransaction.ts b/src/model/transaction/AliasTransaction.ts index 579f9d4969..2333bd04be 100644 --- a/src/model/transaction/AliasTransaction.ts +++ b/src/model/transaction/AliasTransaction.ts @@ -14,9 +14,7 @@ * limitations under the License. */ -import { MosaicSupplyChangeTransaction as MosaicSupplyChangeTransactionLibrary, VerifiableTransaction } from 'nem2-library'; import { Address } from '../account/Address'; -import { PublicAccount } from '../account/PublicAccount'; import { NetworkType } from '../blockchain/NetworkType'; import { MosaicId } from '../mosaic/MosaicId'; import { AliasActionType } from '../namespace/AliasActionType'; @@ -26,9 +24,6 @@ import { AddressAliasTransaction } from './AddressAliasTransaction'; import { Deadline } from './Deadline'; import { MosaicAliasTransaction } from './MosaicAliasTransaction'; import { Transaction } from './Transaction'; -import { TransactionInfo } from './TransactionInfo'; -import { TransactionType } from './TransactionType'; -import { TransactionVersion } from './TransactionVersion'; export abstract class AliasTransaction extends Transaction { diff --git a/src/model/transaction/HashType.ts b/src/model/transaction/HashType.ts index df42501603..6219e7cb05 100644 --- a/src/model/transaction/HashType.ts +++ b/src/model/transaction/HashType.ts @@ -21,7 +21,7 @@ * 2: Op_Hash_160 (first with SHA-256 and then with RIPEMD-160 (BTC compatibility)) * 3: Op_Hash_256: input is hashed twice with SHA-256 (BTC compatibility) */ -import {convert} from 'nem2-library'; +import {Convert as convert} from '../../core/format'; export enum HashType { Op_Sha3_256 = 0, diff --git a/src/model/transaction/RegisterNamespaceTransaction.ts b/src/model/transaction/RegisterNamespaceTransaction.ts index 5cbabf32e3..09e64be488 100644 --- a/src/model/transaction/RegisterNamespaceTransaction.ts +++ b/src/model/transaction/RegisterNamespaceTransaction.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import { convert, NamespaceCreationTransaction as RegisterNamespaceTransactionLibrary, subnamespaceNamespaceId, subnamespaceParentId, namespaceId, VerifiableTransaction } from 'nem2-library'; +import { NamespaceCreationTransaction as RegisterNamespaceTransactionLibrary, subnamespaceNamespaceId, subnamespaceParentId, namespaceId, VerifiableTransaction } from 'nem2-library'; +import { Convert as convert} from '../../core/format'; import { PublicAccount } from '../account/PublicAccount'; import { NetworkType } from '../blockchain/NetworkType'; import { NamespaceId } from '../namespace/NamespaceId'; diff --git a/src/model/transaction/SecretLockTransaction.ts b/src/model/transaction/SecretLockTransaction.ts index 2d66cd3612..d27418ebb0 100644 --- a/src/model/transaction/SecretLockTransaction.ts +++ b/src/model/transaction/SecretLockTransaction.ts @@ -13,7 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import { convert, SecretLockTransaction as SecretLockTransactionLibrary, VerifiableTransaction } from 'nem2-library'; +import { SecretLockTransaction as SecretLockTransactionLibrary, VerifiableTransaction } from 'nem2-library'; +import { Convert as convert} from '../../core/format'; import { Address } from '../account/Address'; import { PublicAccount } from '../account/PublicAccount'; import { NetworkType } from '../blockchain/NetworkType'; diff --git a/src/model/transaction/SecretProofTransaction.ts b/src/model/transaction/SecretProofTransaction.ts index 644e7fe023..d05635f2d1 100644 --- a/src/model/transaction/SecretProofTransaction.ts +++ b/src/model/transaction/SecretProofTransaction.ts @@ -13,7 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import { convert, SecretProofTransaction as SecretProofTransactionLibrary, VerifiableTransaction } from 'nem2-library'; +import { SecretProofTransaction as SecretProofTransactionLibrary, VerifiableTransaction } from 'nem2-library'; +import { Convert as convert} from '../../core/format'; import { Address } from '../account/Address'; import { PublicAccount } from '../account/PublicAccount'; import { NetworkType } from '../blockchain/NetworkType'; diff --git a/src/model/transaction/TransferTransaction.ts b/src/model/transaction/TransferTransaction.ts index 5994c63f81..ddf7b7fca2 100644 --- a/src/model/transaction/TransferTransaction.ts +++ b/src/model/transaction/TransferTransaction.ts @@ -14,7 +14,8 @@ * limitations under the License. */ -import { convert, TransferTransaction as TransferTransactionLibrary, VerifiableTransaction } from 'nem2-library'; +import { TransferTransaction as TransferTransactionLibrary, VerifiableTransaction } from 'nem2-library'; +import { Convert as convert} from '../../core/format'; import { Address } from '../account/Address'; import { PublicAccount } from '../account/PublicAccount'; import { NetworkType } from '../blockchain/NetworkType'; diff --git a/src/model/wallet/SimpleWallet.ts b/src/model/wallet/SimpleWallet.ts index 3a130134f4..2797c6a3cb 100644 --- a/src/model/wallet/SimpleWallet.ts +++ b/src/model/wallet/SimpleWallet.ts @@ -15,7 +15,8 @@ */ import {LocalDateTime} from 'js-joda'; -import {convert, crypto, KeyPair, nacl_catapult} from 'nem2-library'; +import {crypto, KeyPair, nacl_catapult} from 'nem2-library'; +import { Convert as convert} from '../../core/format'; import {Account} from '../account/Account'; import {Address} from '../account/Address'; import {NetworkType} from '../blockchain/NetworkType'; diff --git a/test/core/format/Base32.spec.ts b/test/core/format/Base32.spec.ts new file mode 100644 index 0000000000..ff414f02f9 --- /dev/null +++ b/test/core/format/Base32.spec.ts @@ -0,0 +1,188 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {Convert as convert} from '../../../src/core/format'; +import {Base32 as base32} from '../../../src/core/format/Base32'; + +describe('base32', () => { + const Test_Vectors = [{ + decoded: '68BA9E8D1AA4502E1F73DA19784B5D7DA16CA1E4AF895FAC12', + encoded: 'NC5J5DI2URIC4H3T3IMXQS25PWQWZIPEV6EV7LAS' + }, + { + decoded: '684C2605E5B366BB94BC30755EC9F50D74E80FC9283D20E283', + encoded: 'NBGCMBPFWNTLXFF4GB2V5SPVBV2OQD6JFA6SBYUD' + }, + { + decoded: '68D7B09A14BEA7CE060E71C0FA9AC9B4226DE167013DE10B3D', + encoded: 'NDL3BGQUX2T44BQOOHAPVGWJWQRG3YLHAE66CCZ5' + }, + { + decoded: '686C44C024F1089669F53C45AC6D62CC17A0D9CBA67A6205E6', + encoded: 'NBWEJQBE6EEJM2PVHRC2Y3LCZQL2BWOLUZ5GEBPG' + }, + { + decoded: '98A0FE84BBFC5EEE7CADC2B12F790DAA4A7A9505096E674FAB', + encoded: 'TCQP5BF37RPO47FNYKYS66INVJFHVFIFBFXGOT5L' + } + ]; + + describe('encode', () => { + it('can convert empty input', () => { + // Act: + const encoded = base32.Base32Encode(new Uint8Array([])); + + // Assert: + expect(encoded).to.equal(''); + }); + + it('can convert test vectors', () => { + // Arrange: + for (const sample of Test_Vectors) { + const input = convert.hexToUint8(sample.decoded); + + // Act: + const encoded = base32.Base32Encode(input); + + // Assert: + expect(encoded, `input ${sample.decoded}`).to.equal(sample.encoded); + } + }); + + it('accepts all byte values', () => { + // Arrange: + const data: any = []; + for (let i = 0; 260 > i; ++i) { + data.push(i & 0xFF); + } + + // Act: + const encoded = base32.Base32Encode(data); + + // Assert: + const expected = + 'AAAQEAYEAUDAOCAJBIFQYDIOB4IBCEQTCQKRMFYY' + + 'DENBWHA5DYPSAIJCEMSCKJRHFAUSUKZMFUXC6MBR' + + 'GIZTINJWG44DSOR3HQ6T4P2AIFBEGRCFIZDUQSKK' + + 'JNGE2TSPKBIVEU2UKVLFOWCZLJNVYXK6L5QGCYTD' + + 'MRSWMZ3INFVGW3DNNZXXA4LSON2HK5TXPB4XU634' + + 'PV7H7AEBQKBYJBMGQ6EITCULRSGY5D4QSGJJHFEV' + + 'S2LZRGM2TOOJ3HU7UCQ2FI5EUWTKPKFJVKV2ZLNO' + + 'V6YLDMVTWS23NN5YXG5LXPF5X274BQOCYPCMLRWH' + + 'ZDE4VS6MZXHM7UGR2LJ5JVOW27MNTWW33TO55X7A' + + '4HROHZHF43T6R2PK5PWO33XP6DY7F47U6X3PP6HZ' + + '7L57Z7P674AACAQD'; + expect(encoded).to.equal(expected); + }); + + it('throws if input size is not a multiple of block size', () => { + // Arrange: + for (let i = 2; 10 > i; i += 2) { + const input = new Uint8Array(i); + + // Act + Assert: + expect(() => { + base32.Base32Encode(input); + }, `input at ${i}`).to.throw('decoded size must be multiple of 5'); + } + }); + }); + + describe('decode', () => { + it('can convert empty input', () => { + // Act: + const decoded = base32.Base32Decode(''); + + // Assert: + expect(convert.uint8ToHex(decoded)).to.equal(''); + }); + + it('can convert test vectors', () => { + // Arrange: + for (const sample of Test_Vectors) { + // Act: + const decoded = base32.Base32Decode(sample.encoded); + + // Assert: + expect(convert.uint8ToHex(decoded), `input ${sample.encoded}`).to.equal(sample.decoded); + } + }); + + it('accepts all valid characters', () => { + // Act: + const decoded = base32.Base32Decode('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'); + + // Assert: + expect(convert.uint8ToHex(decoded)).to.equal('00443214C74254B635CF84653A56D7C675BE77DF'); + }); + + it('throws if input size is not a multiple of block size', () => { + // Arrange: + for (let i = 1; 8 > i; ++i) { + const input = 'A'.repeat(i); + + // Act + Assert: + expect(() => { + base32.Base32Decode(input); + }, `input at ${i}`).to.throw('encoded size must be multiple of 8'); + } + }); + + it('throws if input contains an invalid character', () => { + // Arrange: + const illegalInputs = [ + 'NC5J5DI2URIC4H3T3IMXQS21PWQWZIPEV6EV7LAS', // contains char '1' + 'NBGCMBPFWNTLXFF4GB2V5SPV!V2OQD6JFA6SBYUD', // contains char '!' + 'NDL3BGQUX2T44BQOOHAPVGWJWQRG3YLHAE)6CCZ5' // contains char ')' + ]; + + // Act + Assert: + for (const input of illegalInputs) { + expect(() => { + base32.Base32Decode(input); + }, `input ${input}`).to.throw('illegal base32 character'); + } + }); + }); + + describe('roundtrip', () => { + it('decode -> encode', () => { + // Arrange: inputs + const inputs = ['BDS73DQ5NC33MKYI3K6GXLJ53C2HJ35A', '46FNYP7T4DD3SWAO6C4NX62FJI5CBA26']; + for (const input of inputs) { + // Act: + const decoded = base32.Base32Decode(input); + const result = base32.Base32Encode(decoded); + + // Assert: + expect(result, `input ${input}`).to.equal(input); + } + }); + + it('encode -> decode', () => { + // Arrange: inputs + const inputs = ['8A4E7DF5B61CC0F97ED572A95F6ACA', '2D96E4ABB65F0AD3C29FEA48C132CE']; + for (const input of inputs) { + // Act: + const encoded = base32.Base32Encode(convert.hexToUint8(input)); + const result = base32.Base32Decode(encoded); + + // Assert: + expect(convert.uint8ToHex(result), `input ${input}`).to.equal(input); + } + }); + }); +}); diff --git a/test/core/format/Convert.spec.ts b/test/core/format/Convert.spec.ts new file mode 100644 index 0000000000..d40aa5b8b0 --- /dev/null +++ b/test/core/format/Convert.spec.ts @@ -0,0 +1,352 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {Convert as convert} from '../../../src/core/format'; + +describe('convert', () => { + describe('toByte', () => { + it('can convert all valid hex char combinations to byte', () => { + // Arrange: + const charToValueMappings: any = []; + for (let code = '0'.charCodeAt(0); code <= '9'.charCodeAt(0); ++code) { + charToValueMappings.push([String.fromCharCode(code), code - '0'.charCodeAt(0)]); + } + for (let code = 'a'.charCodeAt(0); code <= 'f'.charCodeAt(0); ++code) { + charToValueMappings.push([String.fromCharCode(code), code - 'a'.charCodeAt(0) + 10]); + } + for (let code = 'A'.charCodeAt(0); code <= 'F'.charCodeAt(0); ++code) { + charToValueMappings.push([String.fromCharCode(code), code - 'A'.charCodeAt(0) + 10]); + } + + // Act: + let numTests = 0; + charToValueMappings.forEach((pair1) => { + charToValueMappings.forEach((pair2) => { + // Act: + const byte = convert.toByte(pair1[0], pair2[0]); + + // Assert: + const expected = (pair1[1] * 16) + pair2[1]; + expect(byte, `input: ${pair1[0]}${pair2[0]}`).to.equal(expected); + ++numTests; + }); + }); + + // Sanity: + expect(numTests).to.equal(22 * 22); + }); + + it('cannot convert invalid hex chars to byte', () => { + // Arrange: + const pairs = [ + ['G', '6'], + ['7', 'g'], + ['*', '8'], + ['9', '!'], + ]; + + // Act: + pairs.forEach((pair) => { + // Assert: + const message = `input: ${pair[0]}${pair[0]}`; + expect(() => { + convert.toByte(pair[0], pair[1]); + }, message).to.throw('unrecognized hex char'); + }); + }); + }); + + describe('isHexString', () => { + it('returns true for valid hex strings', () => { + // Arrange: + const inputs = [ + '', + '026ee415fc15', + 'abcdef0123456789ABCDEF', + ]; + + // Act: + for (const input of inputs) { + const isHexString = convert.isHexString(input); + + // Assert: + expect(isHexString, `input ${input}`).to.equal(true); + } + }); + + it('returns false for invalid hex strings', () => { + // Arrange: + const inputs = [ + 'abcdef012345G789ABCDEF', // invalid ('G') char + 'abcdef0123456789ABCDE', // invalid (odd) length + ]; + + // Act: + for (const input of inputs) { + const isHexString = convert.isHexString(input); + + // Assert: + expect(isHexString, `input ${input}`).to.equal(false); + } + }); + }); + + describe('hexToUint8', () => { + it('can parse empty hex string into array', () => { + // Act: + const actual = convert.hexToUint8(''); + + // Assert: + const expected = Uint8Array.of(); + expect(actual).to.deep.equal(expected); + }); + + it('can parse valid hex string into array', () => { + // Act: + const actual = convert.hexToUint8('026ee415fc15'); + + // Assert: + const expected = Uint8Array.of(0x02, 0x6E, 0xE4, 0x15, 0xFC, 0x15); + expect(actual).to.deep.equal(expected); + }); + + it('can parse valid hex string containing all valid hex characters into array', () => { + // Act: + const actual = convert.hexToUint8('abcdef0123456789ABCDEF'); + + // Assert: + const expected = Uint8Array.of(0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF); + expect(actual).to.deep.equal(expected); + }); + + it('cannot parse hex string with invalid characters into array', () => { + // Assert: + expect(() => { + convert.hexToUint8('abcdef012345G789ABCDEF'); + }).to.throw('unrecognized hex char'); + }); + + it('cannot parse hex string with invalid size into array', () => { + // Assert: + expect(() => { + convert.hexToUint8('abcdef012345G789ABCDE'); + }).to.throw('hex string has unexpected size'); + }); + }); + + describe('uint8ToHex', () => { + it('can format empty array into hex string', () => { + // Act: + const actual = convert.uint8ToHex(Uint8Array.of()); + + // Assert: + expect(actual).to.equal(''); + }); + + it('can format single value array into hex string', () => { + // Act: + const actual = convert.uint8ToHex(Uint8Array.of(0xD2)); + + // Assert: + expect(actual).to.equal('D2'); + }); + + it('can format multi value array into hex string', () => { + // Act: + const actual = convert.uint8ToHex(Uint8Array.of(0x02, 0x6E, 0xE4, 0x15, 0xFC, 0x15)); + + // Assert: + expect(actual).to.equal('026EE415FC15'); + }); + }); + + describe('uint8ToUint32', () => { + it('uint8 array with zero length can be converted to uint32 array', () => { + // Act: + const actual = convert.uint8ToUint32(Uint8Array.of()); + + // Assert: + expect(actual).to.deep.equal(Uint32Array.of()); + }); + + it('uint8 array with length multiple of four can be converted to uint32 array', () => { + // Act: + const actual = convert.uint8ToUint32(Uint8Array.of(0x02, 0x6E, 0x89, 0xAB, 0xCD, 0xEF, 0xE4, 0x15)); + + // Assert: + expect(actual).to.deep.equal(Uint32Array.of(0xAB896E02, 0x15E4EFCD)); + }); + + it('uint8 array with length not multiple of four cannot be converted to uint32 array', () => { + // Assert: + expect(() => { + convert.uint8ToUint32(Uint8Array.of(0x02, 0x6E, 0xE4, 0x15, 0x15)); + }) + .to.throw('byte length of Uint32Array should be a multiple of 4'); + }); + }); + + describe('uint32ToUint8', () => { + it('uint32 array with zero length can be converted to uint8 array', () => { + // Act: + const actual = convert.uint32ToUint8(Uint32Array.of()); + + // Assert: + expect(actual).to.deep.equal(Uint8Array.of()); + }); + + it('uint32 array with nonzero length can be converted to uint8 array', () => { + // Act: + const actual = convert.uint32ToUint8(Uint32Array.of(0xAB896E02, 0x15E4EFCD)); + + // Assert: + expect(actual).to.deep.equal(Uint8Array.of(0x02, 0x6E, 0x89, 0xAB, 0xCD, 0xEF, 0xE4, 0x15)); + }); + }); + + describe('utf8ToHex', () => { + it('utf8 text to hex', () => { + // Act: + const actual = convert.utf8ToHex('test words |@#¢∞¬÷“”≠[]}{–'); + + // Assert: + expect(actual).to.equal('7465737420776f726473207c4023c2a2e2889ec2acc3b7e2809ce2809de289a05b5d7d7be28093'); + }); + + it('utf8 text to hex', () => { + // Act: + const actual = convert.utf8ToHex('先秦兩漢'); + + // Assert: + expect(actual).to.equal('e58588e7a7a6e585a9e6bca2'); + }); + }); + + describe('signed <-> unsigned byte', () => { + const testCases = [{ + signed: -128, + unsigned: 0x80, + description: 'min negative', + }, + { + signed: -127, + unsigned: 0x81, + description: 'min negative plus one', + }, + { + signed: -87, + unsigned: 0xA9, + description: 'negative', + }, + { + signed: -1, + unsigned: 0xFF, + description: 'negative one', + }, + { + signed: 0, + unsigned: 0, + description: 'zero', + }, + { + signed: 1, + unsigned: 0x01, + description: 'positive one', + }, + { + signed: 57, + unsigned: 0x39, + description: 'positive', + }, + { + signed: 126, + unsigned: 0x7E, + description: 'max positive minus one', + }, + { + signed: 127, + unsigned: 0x7F, + description: 'max positive', + }, + ]; + + describe('uint8ToInt8', () => { + const failureTestCases = [{ + input: 256, + description: 'one too large', + }, + { + input: 1000, + description: 'very large', + }, + ]; + + for (const testCase of failureTestCases) { + it(`cannot convert number that is ${testCase.description}`, () => { + // Assert: + expect(() => convert.uint8ToInt8(testCase.input)).to.throw(`input '${testCase.input}' is out of range`); + }); + } + + for (const testCase of testCases) { + it(`can convert ${testCase.description}`, () => { + // Act: + const value = convert.uint8ToInt8(testCase.unsigned); + + // Assert: + expect(value).to.equal(testCase.signed); + }); + } + }); + + describe('int8ToUint8', () => { + const failureTestCases = [{ + input: -1000, + description: 'very small', + }, + { + input: -129, + description: 'one too small', + }, + { + input: 128, + description: 'one too large', + }, + { + input: 1000, + description: 'very large', + }, + ]; + + for (const testCase of failureTestCases) { + it(`cannot convert number that is ${testCase.description}`, () => { + // Assert: + expect(() => convert.int8ToUint8(testCase.input)).to.throw(`input '${testCase.input}' is out of range`); + }); + } + + for (const testCase of testCases) { + it(`can convert ${testCase.description}`, () => { + // Act: + const value = convert.int8ToUint8(testCase.signed); + + // Assert: + expect(value).to.equal(testCase.unsigned); + }); + } + }); + }); +}); diff --git a/test/core/format/IdGenerator.spec.ts b/test/core/format/IdGenerator.spec.ts new file mode 100644 index 0000000000..32921fd12b --- /dev/null +++ b/test/core/format/IdGenerator.spec.ts @@ -0,0 +1,251 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {sha3_256} from 'js-sha3'; +import { + Convert as convert, + IdGenerator as idGenerator, + RawUInt64 as uint64, +} from '../../../src/core/format'; + +const constants = { + nem_id: [0x375FFA4B, 0x84B3552D], + xem_id: [0xD95FCF29, 0xD525AD41], + namespace_base_id: [0, 0], +}; + +const basicMosaicInfo = { + nonce: [0x78, 0xE3, 0x6F, 0xB7], + publicId: [ + 0x4A, 0xFF, 0x7B, 0x4B, 0xA8, 0xC1, 0xC2, 0x6A, 0x79, 0x17, 0x57, 0x59, 0x93, 0x34, 0x66, 0x27, + 0xCB, 0x6C, 0x80, 0xDE, 0x62, 0xCD, 0x92, 0xF7, 0xF9, 0xAE, 0xDB, 0x70, 0x64, 0xA3, 0xDE, 0x62, + ], + id: [0xC0AFC518, 0x3AD842A8], +}; + +const mosaicTestVector = { + rows: [{ + publicKey: '4AFF7B4BA8C1C26A7917575993346627CB6C80DE62CD92F7F9AEDB7064A3DE62', + nonce: 'B76FE378', + expectedMosaicId: '3AD842A8C0AFC518', + }, + { + publicKey: '3811EDF245F1D30171FF1474B24C4366FECA365A8457AAFA084F3DE4AEA0BA60', + nonce: '21832A2A', + expectedMosaicId: '24C54740A9F3893F', + }, + { + publicKey: '3104D468D20491EC12C988C50CAD9282256052907415359201C46CBD7A0BCD75', + nonce: '2ADBB332', + expectedMosaicId: '43908F2DEEA04245', + }, + { + publicKey: '6648E16513F351E9907B0EA34377E25F579BE640D4698B28E06585A21E94CFE2', + nonce: 'B9175E0F', + expectedMosaicId: '183172772BD29E78', + }, + { + publicKey: '1C05C40D38463FE725CF0584A3A69E3B0D6B780196A88C50624E49B921EE1404', + nonce: 'F6077DDD', + expectedMosaicId: '423DB0B12F787422', + }, + { + publicKey: '37926B3509987093C776C8EA3E7F978E3A78142B5C96B9434C3376177DC65EFD', + nonce: '08190C6D', + expectedMosaicId: '1F07D26B6CD352D5', + }, + { + publicKey: 'FDC6B0D415D90536263431F05C46AC492D0BD9B3CFA1B79D5A35E0F371655C0C', + nonce: '81662AA5', + expectedMosaicId: '74511F54940729CB', + }, + { + publicKey: '2D4EA99965477AEB3BC162C09C24C8DA4DABE408956C2F69642554EA48AAE1B2', + nonce: 'EA16BF58', + expectedMosaicId: '4C55843B6EB4A5BD', + }, + { + publicKey: '68EB2F91E74D005A7C22D6132926AEF9BFD90A3ACA3C7F989E579A93EFF24D51', + nonce: 'E5F87A8B', + expectedMosaicId: '4D89DE2B6967666A', + }, + { + publicKey: '3B082C0074F65D1E205643CDE72C6B0A3D0579C7ACC4D6A7E23A6EC46363B90F', + nonce: '1E6BB49F', + expectedMosaicId: '0A96B3A44615B62F', + }, + { + publicKey: '81245CA233B729FAD1752662EADFD73C5033E3B918CE854E01F6EB51E98CD9F1', + nonce: 'B82965E3', + expectedMosaicId: '1D6D8E655A77C4E6', + }, + { + publicKey: 'D3A2C1BFD5D48239001174BFF62A83A52BC9A535B8CDBDF289203146661D8AC4', + nonce: 'F37FB460', + expectedMosaicId: '268A3CC23ADCDA2D', + }, + { + publicKey: '4C4CA89B7A31C42A7AB963B8AB9D85628BBB94735C999B2BD462001A002DBDF3', + nonce: 'FF6323B0', + expectedMosaicId: '51202B5C51F6A5A9', + }, + { + publicKey: '2F95D9DCD4F18206A54FA95BD138DA1C038CA82546525A8FCC330185DA0647DC', + nonce: '99674492', + expectedMosaicId: '5CE4E38B09F1423D', + }, + { + publicKey: 'A7892491F714B8A7469F763F695BDB0B3BF28D1CC6831D17E91F550A2D48BD12', + nonce: '55141880', + expectedMosaicId: '5EFD001B3350C9CB', + }, + { + publicKey: '68BBDDF5C08F54278DA516F0E4A5CCF795C10E2DE26CAF127FF4357DA7ACF686', + nonce: '11FA5BAF', + expectedMosaicId: '179F0CDD6D2CCA7B', + }, + { + publicKey: '014F6EF90792F814F6830D64017107534F5B718E2DD43C25ACAABBE347DEC81E', + nonce: '6CFBF7B3', + expectedMosaicId: '53095813DEB3D108', + }, + { + publicKey: '95A6344597E0412C51B3559F58F564F9C2DE3101E5CC1DD8B115A93CE7040A71', + nonce: '905EADFE', + expectedMosaicId: '3551C4B12DDF067D', + }, + { + publicKey: '0D7DDFEB652E8B65915EA734420A1233A233119BF1B0D41E1D5118CDD44447EE', + nonce: '61F5B671', + expectedMosaicId: '696E2FB0682D3199', + }, + { + publicKey: 'FFD781A20B01D0C999AABC337B8BAE82D1E7929A9DD77CC1A71E4B99C0749684', + nonce: 'D8542F1A', + expectedMosaicId: '6C55E05D11D19FBD', + }, + ], +}; + +describe('id generator', () => { + function generateNamespaceId(parentId, name) { + const hash = sha3_256.create(); + hash.update(Uint32Array.from(parentId).buffer); + hash.update(name); + const result = new Uint32Array(hash.arrayBuffer()); + // right zero-filling required to keep unsigned number representation + return [result[0], (result[1] | 0x80000000) >>> 0]; + } + + function addBasicTests(generator) { + it('produces different results for different names', () => { + // Assert: + ['bloodyrookie.alice', 'nem.mex', 'bloodyrookie.xem', 'bloody_rookie.xem'].forEach((name) => + expect(generator(name), `nem.xem vs ${name}`).to.not.equal(generator('nem.xem'))); + }); + + it('rejects names with uppercase characters', () => { + // Assert: + ['NEM.xem', 'NEM.XEM', 'nem.XEM', 'nEm.XeM', 'NeM.xEm'].forEach((name) => + expect(() => generator(name), `name ${name}`).to.throw('invalid part name')); + }); + + it('rejects improper qualified names', () => { + // Assert: + ['.', '..', '...', '.a', 'b.', 'a..b', '.a.b', 'b.a.'].forEach((name) => + expect(() => generator(name), `name ${name}`).to.throw('empty part')); + }); + + it('rejects improper part names', () => { + // Assert: + ['alpha.bet@.zeta', 'a!pha.beta.zeta', 'alpha.beta.ze^a'].forEach((name) => + expect(() => generator(name), `name ${name}`).to.throw('invalid part name')); + }); + + it('rejects empty string', () => { + // Assert: + expect(() => generator(''), 'empty string').to.throw('having zero length'); + }); + } + + describe('generate mosaic id', () => { + it('generates correct well known id', () => { + // Assert: + expect(idGenerator.generateMosaicId(basicMosaicInfo.nonce, basicMosaicInfo.publicId)) + .to.deep.equal(basicMosaicInfo.id); + }); + + // @dataProvider mosaicTestVector + it('generates correct mosaicId given nonce and public key', () => { + mosaicTestVector.rows.map((row, i) => { + const pubKey = convert.hexToUint8(row.publicKey); + const nonce = convert.hexToUint8(row.nonce).reverse(); // Little-Endianness! + const mosaicId = idGenerator.generateMosaicId(nonce, pubKey); + const expectedId = uint64.fromHex(row.expectedMosaicId); + + // Assert: + expect(mosaicId) + .to.deep.equal(expectedId); + }); + }); + }); + + describe('generate namespace paths', () => { + it('generates correct well known root path', () => { + // Act: + const path = idGenerator.generateNamespacePath('nem'); + + // Assert: + expect(path.length).to.equal(1); + expect(path[0]).to.deep.equal(constants.nem_id); + }); + + it('generates correct well known child path', () => { + // Act: + const path = idGenerator.generateNamespacePath('nem.xem'); + + // Assert: + expect(path.length).to.equal(2); + expect(path[0]).to.deep.equal(constants.nem_id); + expect(path[1]).to.deep.equal(constants.xem_id); + }); + + it('supports multi level namespaces', () => { + // Arrange: + const expected: any = []; + expected.push(generateNamespaceId(constants.namespace_base_id, 'foo')); + expected.push(generateNamespaceId(expected[0], 'bar')); + expected.push(generateNamespaceId(expected[1], 'baz')); + + // Assert: + expect(idGenerator.generateNamespacePath('foo.bar.baz')).to.deep.equal(expected); + }); + + it('rejects names with too many parts', () => { + // Assert: + ['a.b.c.d', 'a.b.c.d.e'].forEach((name) => + expect(() => idGenerator.generateNamespacePath(name), `name ${name}`).to.throw('too many parts')); + }); + + it('rejects improper qualified names', () => { + // Assert: + ['a:b:c', 'a::b'].forEach((name) => + expect(() => idGenerator.generateNamespacePath(name), `name ${name}`).to.throw('invalid part name')); + }); + + addBasicTests(idGenerator.generateNamespacePath); + }); +}); diff --git a/test/core/format/RawAddress.spec.ts b/test/core/format/RawAddress.spec.ts new file mode 100644 index 0000000000..c6580fb656 --- /dev/null +++ b/test/core/format/RawAddress.spec.ts @@ -0,0 +1,216 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import { + Convert as convert, + RawAddress as address, +} from '../../../src/core/format'; + +const Address_Decoded_Size = 25; +const Network_Mijin_Identifier = 0x60; +const Network_Public_Test_Identifier = 0x98; + +describe('address', () => { + describe('stringToAddress', () => { + function assertCannotCreateAddress(encoded, message) { + // Assert: + expect(() => { + address.stringToAddress(encoded); + }).to.throw(message); + } + + it('can create address from valid encoded address', () => { + // Arrange: + const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFG'; + const expectedHex = '6823BB7C3C089D996585466380EDBDC19D4959184893E38CA6'; + + // Act: + const decoded = address.stringToAddress(encoded); + + // Assert: + expect(address.isValidAddress(decoded)).to.equal(true); + expect(convert.uint8ToHex(decoded)).to.equal(expectedHex); + }); + + it('cannot create address from encoded string with wrong length', () => { + // Assert: + assertCannotCreateAddress( + 'NC5J5DI2URIC4H3T3IMXQS25PWQWZIPEV6EV7LASABCDEFGH', + 'NC5J5DI2URIC4H3T3IMXQS25PWQWZIPEV6EV7LASABCDEFGH does not represent a valid encoded address' + ); + }); + + it('cannot create address from invalid encoded string', () => { + // Assert: + assertCannotCreateAddress('NC5(5DI2URIC4H3T3IMXQS25PWQWZIPEV6EV7LAS', 'illegal base32 character ('); + assertCannotCreateAddress('NC5J1DI2URIC4H3T3IMXQS25PWQWZIPEV6EV7LAS', 'illegal base32 character 1'); + assertCannotCreateAddress('NC5J5?I2URIC4H3T3IMXQS25PWQWZIPEV6EV7LAS', 'illegal base32 character ?'); + }); + }); + + describe('addressToString', () => { + it('can create encoded address from address', () => { + // Arrange: + const decodedHex = '6823BB7C3C089D996585466380EDBDC19D4959184893E38CA6'; + const expected = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFG'; + + // Act: + const encoded = address.addressToString(convert.hexToUint8(decodedHex)); + + // Assert: + expect(encoded).to.equal(expected); + }); + }); + + describe('publicKeyToAddress', () => { + it('can create address from public key for well known network', () => { + // Arrange: + const expectedHex = '6023BB7C3C089D996585466380EDBDC19D49591848B3727714'; + const publicKey = convert.hexToUint8('3485D98EFD7EB07ADAFCFD1A157D89DE2796A95E780813C0258AF3F5F84ED8CB'); + + // Act: + const decoded = address.publicKeyToAddress(publicKey, Network_Mijin_Identifier); + + // Assert: + expect(decoded[0]).to.equal(Network_Mijin_Identifier); + expect(address.isValidAddress(decoded)).to.equal(true); + expect(convert.uint8ToHex(decoded)).to.equal(expectedHex); + }); + + it('can create address from public key for custom network', () => { + // Arrange: + const expectedHex = '9823BB7C3C089D996585466380EDBDC19D495918484BF7E997'; + const publicKey = convert.hexToUint8('3485D98EFD7EB07ADAFCFD1A157D89DE2796A95E780813C0258AF3F5F84ED8CB'); + + // Act: + const decoded = address.publicKeyToAddress(publicKey, Network_Public_Test_Identifier); + + // Assert: + expect(decoded[0]).to.equal(Network_Public_Test_Identifier); + expect(address.isValidAddress(decoded)).to.equal(true); + expect(convert.uint8ToHex(decoded)).to.equal(expectedHex); + }); + + it('address calculation is deterministic', () => { + // Arrange: + const publicKey = convert.hexToUint8('3485D98EFD7EB07ADAFCFD1A157D89DE2796A95E780813C0258AF3F5F84ED8CB'); + + // Act: + const decoded1 = address.publicKeyToAddress(publicKey, Network_Mijin_Identifier); + const decoded2 = address.publicKeyToAddress(publicKey, Network_Mijin_Identifier); + + // Assert: + expect(address.isValidAddress(decoded1)).to.equal(true); + expect(decoded1).to.deep.equal(decoded2); + }); + + it('different public keys result in different addresses', () => { + // Arrange: + const publicKey1 = convert.hexToUint8('1464953393CE96A08ABA6184601FD08864E910696B060FF7064474726E666CA8'); + const publicKey2 = convert.hexToUint8('b4f12e7c9f6946091e2cb8b6d3a12b50d17ccbbf646386ea27ce2946a7423dcf'); + + // Act: + const decoded1 = address.publicKeyToAddress(publicKey1, Network_Mijin_Identifier); + const decoded2 = address.publicKeyToAddress(publicKey2, Network_Mijin_Identifier); + + // Assert: + expect(address.isValidAddress(decoded1)).to.equal(true); + expect(address.isValidAddress(decoded2)).to.equal(true); + expect(decoded1).to.not.deep.equal(decoded2); + }); + + it('different networks result in different addresses', () => { + // Arrange: + const publicKey = convert.hexToUint8('b4f12e7c9f6946091e2cb8b6d3a12b50d17ccbbf646386ea27ce2946a7423dcf'); + + // Act: + const decoded1 = address.publicKeyToAddress(publicKey, Network_Mijin_Identifier); + const decoded2 = address.publicKeyToAddress(publicKey, Network_Public_Test_Identifier); + + // Assert: + expect(address.isValidAddress(decoded1)).to.equal(true); + expect(address.isValidAddress(decoded2)).to.equal(true); + expect(decoded1).to.not.deep.equal(decoded2); + }); + }); + + describe('isValidAddress', () => { + it('returns true for valid address', () => { + // Arrange: + const validHex = '6823BB7C3C089D996585466380EDBDC19D4959184893E38CA6'; + const decoded = convert.hexToUint8(validHex); + + // Assert: + expect(address.isValidAddress(decoded)).to.equal(true); + }); + + it('returns false for address with invalid checksum', () => { + // Arrange: + const validHex = '6823BB7C3C089D996585466380EDBDC19D4959184893E38CA6'; + const decoded = convert.hexToUint8(validHex); + decoded[Address_Decoded_Size - 1] ^= 0xff; // ruin checksum + + // Assert: + expect(address.isValidAddress(decoded)).to.equal(false); + }); + + it('returns false for address with invalid hash', () => { + // Arrange: + const validHex = '6823BB7C3C089D996585466380EDBDC19D4959184893E38CA6'; + const decoded = convert.hexToUint8(validHex); + decoded[5] ^= 0xff; // ruin ripemd160 hash + + // Assert: + expect(address.isValidAddress(decoded)).to.equal(false); + }); + }); + + describe('isValidEncodedAddress', () => { + it('returns true for valid encoded address', () => { + // Arrange: + const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFG'; + + // Assert: + expect(address.isValidEncodedAddress(encoded)).to.equal(true); + }); + + it('returns false for invalid encoded address', () => { + // Arrange: changed last char + const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFH'; + + // Assert: + expect(address.isValidEncodedAddress(encoded)).to.equal(false); + }); + + it('returns false for encoded address with wrong length', () => { + // Arrange: added ABC + const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFGABC'; + + // Assert: + expect(address.isValidEncodedAddress(encoded)).to.equal(false); + }); + + it('adding leading or trailing white space invalidates encoded address', () => { + // Arrange: + const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFG'; + + // Assert: + expect(address.isValidEncodedAddress(` \t ${encoded}`)).to.equal(false); + expect(address.isValidEncodedAddress(`${encoded} \t `)).to.equal(false); + expect(address.isValidEncodedAddress(` \t ${encoded} \t `)).to.equal(false); + }); + }); +}); \ No newline at end of file diff --git a/test/core/format/RawArray.spec.ts b/test/core/format/RawArray.spec.ts new file mode 100644 index 0000000000..a1017c4c05 --- /dev/null +++ b/test/core/format/RawArray.spec.ts @@ -0,0 +1,223 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import { Convert as convert, RawArray as array} from '../../../src/core/format'; + +describe('array', () => { + describe('uint8View', () => { + it('can get uint8 view of array buffer', () => { + // Arrange: + const src = convert.hexToUint8('0A12B5675069'); + + // Act: + const view = array.uint8View(src.buffer); + + // Assert: + expect(convert.uint8ToHex(view)).to.equal('0A12B5675069'); + }); + + it('can get uint8 view of uint8 typed array', () => { + // Arrange: + const src = convert.hexToUint8('0A12B5675069'); + + // Act: + const view = array.uint8View(src); + + // Assert: + expect(convert.uint8ToHex(view)).to.equal('0A12B5675069'); + }); + + it('cannot get uint8 view of arbitrary typed array', () => { + // Arrange: + const src = new Uint16Array(10); + + // Act: + expect(() => array.uint8View(src)).to.throw('unsupported type passed to uint8View'); + }); + }); + + describe('copy', () => { + it('can copy full typed array', () => { + // Arrange: + const src = convert.hexToUint8('0A12B5675069'); + const dest = new Uint8Array(src.length); + + // Act: + array.copy(dest, src); + + // Assert: + expect(convert.uint8ToHex(dest)).to.equal('0A12B5675069'); + }); + + it('can copy partial typed array when dest is same size as src', () => { + // Arrange: + const src = convert.hexToUint8('0A12B5675069'); + const dest = new Uint8Array(src.length); + + // Act: + array.copy(dest, src, 3); + + // Assert: + expect(convert.uint8ToHex(dest)).to.equal('0A12B5000000'); + }); + + it('can copy partial typed array when dest is smaller than src', () => { + // Arrange: + const src = convert.hexToUint8('0A12B5675069'); + const dest = new Uint8Array(4); + + // Act: + array.copy(dest, src); + + // Assert: + expect(convert.uint8ToHex(dest)).to.equal('0A12B567'); + }); + + it('can copy partial typed array with custom offsets', () => { + // Arrange: + const src = convert.hexToUint8('0A12B5675069'); + const dest = new Uint8Array(src.length); + + // Act: + array.copy(dest, src, 3, 2, 1); + + // Assert: + expect(convert.uint8ToHex(dest)).to.equal('000012B56700'); + }); + }); + + describe('isZeroFilled', () => { + it('returns true if typed array is zero', () => { + // Act: + const isZero = array.isZeroFilled(new Uint16Array(10)); + + // Assert: + expect(isZero).to.equal(true); + }); + + function assertIsNonZero(length, nonZeroOffset) { + // Arrange: + const src = new Uint16Array(length); + src[nonZeroOffset] = 2; + + // Act + const isZero = array.isZeroFilled(src); + + // Assert: + expect(isZero, `nonzero offset ${nonZeroOffset}`).to.equal(false); + } + + it('returns false if typed array is non zero', () => { + // Assert: + assertIsNonZero(10, 0); + assertIsNonZero(10, 5); + assertIsNonZero(10, 9); + }); + }); + + describe('deepEqual', () => { + it('returns true if typed arrays are equal', () => { + // Arrange: + const lhs = convert.hexToUint8('0A12B5675069'); + const rhs = convert.hexToUint8('0A12B5675069'); + + // Act: + const isEqual = array.deepEqual(lhs, rhs); + + // Assert: + expect(isEqual).to.equal(true); + }); + + it('returns false if typed arrays have different sizes', () => { + // Arrange: + const shorter = convert.hexToUint8('0A12B5675069'); + const longer = convert.hexToUint8('0A12B567506983'); + + // Act: + const isEqual1 = array.deepEqual(shorter, longer); + const isEqual2 = array.deepEqual(longer, shorter); + + // Assert: + expect(isEqual1).to.equal(false); + expect(isEqual2).to.equal(false); + }); + + function assertNotEqual(lhs, unequalOffset) { + // Arrange: + const rhs = new Uint8Array(lhs.length); + array.copy(rhs, lhs); + rhs[unequalOffset] ^= 0xFF; + + // Act + const isEqual = array.deepEqual(lhs, rhs); + + // Assert: + expect(isEqual, `unequal offset ${unequalOffset}`).to.equal(false); + } + + it('returns false if typed arrays are not equal', () => { + // Arrange: + const lhs = convert.hexToUint8('0A12B5675069'); + + // Assert: + assertNotEqual(lhs, 0); + assertNotEqual(lhs, 3); + assertNotEqual(lhs, 5); + }); + + it('returns true if subset of typed arrays are equal', () => { + // Arrange: different at 2 + const lhs = convert.hexToUint8('0A12B5675069'); + const rhs = convert.hexToUint8('0A12C5675069'); + + // Act: + const isEqualSubset = array.deepEqual(lhs, rhs, 2); + const isEqualAll = array.deepEqual(lhs, rhs); + + // Assert: + expect(isEqualSubset).to.equal(true); + expect(isEqualAll).to.equal(false); + }); + + it('returns true if subset of typed arrays of different lengths are equal', () => { + // Arrange: + const shorter = convert.hexToUint8('0A12B5'); + const longer = convert.hexToUint8('0A12B567506983'); + + // Act: + const isEqual1 = array.deepEqual(shorter, longer, 3); + const isEqual2 = array.deepEqual(longer, shorter, 3); + + // Assert: + expect(isEqual1).to.equal(true); + expect(isEqual2).to.equal(true); + }); + + it('returns false if either typed array has fewer elements than requested for comparison', () => { + // Arrange: + const shorter = convert.hexToUint8('0A12B5'); + const longer = convert.hexToUint8('0A12B567506983'); + + // Act: + const isEqual1 = array.deepEqual(shorter, longer, 4); + const isEqual2 = array.deepEqual(longer, shorter, 4); + + // Assert: + expect(isEqual1).to.equal(false); + expect(isEqual2).to.equal(false); + }); + }); +}); \ No newline at end of file diff --git a/test/core/format/RawUInt64.spec.ts b/test/core/format/RawUInt64.spec.ts new file mode 100644 index 0000000000..f7d3c26bdc --- /dev/null +++ b/test/core/format/RawUInt64.spec.ts @@ -0,0 +1,319 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + expect +} from 'chai'; +import { Convert as convert, RawUInt64 as uint64} from '../../../src/core/format'; + +describe('uint64', () => { + describe('compact', () => { + it('can compact 32 bit value', () => { + // Act: + const result = uint64.compact([0x12345678, 0x00000000]); + + // Assert: + expect(result).to.equal(0x12345678); + }); + + it('can compact less than max safe integer', () => { + // Act: + const result = uint64.compact([0x00ABCDEF, 0x000FDFFF]); + + // Assert: + expect(result).to.equal(0xFDFFF00ABCDEF); + }); + + it('can compact max safe integer', () => { + // Sanity: + expect(0x1FFFFFFFFFFFFF).to.equal(Number.MAX_SAFE_INTEGER); + + // Act: + const result = uint64.compact([0xFFFFFFFF, 0x001FFFFF]); + + // Assert: + expect(result).to.equal(Number.MAX_SAFE_INTEGER); + }); + + it('cannot compact min unsafe integer', () => { + // Sanity: + expect(0x0020000000000000 + 1).to.equal(0x0020000000000000); + + // Act: + const result = uint64.compact([0x00000000, 0x00200000]); + + // Assert: + expect(result).to.deep.equal([0x00000000, 0x00200000]); + }); + + it('cannot compact greater than min unsafe integer', () => { + // Act: + const result = uint64.compact([0xF0000000, 0x01000D00]); + + // Assert: + expect(result).to.deep.equal([0xF0000000, 0x01000D00]); + }); + }); + + describe('fromUint', () => { + // const failureTestCases = [ + // { number: 0x0020000000000000, description: 'min unsafe integer' }, + // { number: 0x01000D00F0000000, description: 'greater than min unsafe integer' }, + // { number: -1, description: 'negative' }, + // { number: 1234.56, description: 'floating point' } + // ]; + + // failureTestCases.forEach(testCase => { + // it(`cannot parse number that is ${testCase.description}`, () => { + // // Assert: + // expect(() => uint64.fromUint(testCase.number)).to.throw(`number cannot be converted to uint '${testCase.number}'`); + // }); + // }); + + const successTestCases = [{ + number: 0, + uint64: [0, 0], + description: '0' + }, + { + number: 0xA1B2, + uint64: [0xA1B2, 0], + description: '(0, 8)' + }, + { + number: 0x12345678, + uint64: [0x12345678, 0], + description: '8' + }, + { + number: 0xABCD12345678, + uint64: [0x12345678, 0xABCD], + description: '(8, 16)' + }, + { + number: 0x0014567890ABCDEF, + uint64: [0x90ABCDEF, 0x00145678], + description: '14' + }, + { + number: Number.MAX_SAFE_INTEGER, + uint64: [0xFFFFFFFF, 0x001FFFFF], + description: '14 (max value)' + } + ]; + + successTestCases.forEach(testCase => { + it(`can parse numeric with ${testCase.description} significant digits`, () => { + // Act: + const value = uint64.fromUint(testCase.number); + + // Assert: + expect(value).to.deep.equal(testCase.uint64); + }); + }); + }); + + const hexTestCases = [{ + str: '0000000000000000', + value: [0, 0], + description: '0' + }, + { + str: '000000000000A1B2', + value: [0xA1B2, 0], + description: '(0, 8)' + }, + { + str: '0000000012345678', + value: [0x12345678, 0], + description: '8' + }, + { + str: '0000ABCD12345678', + value: [0x12345678, 0xABCD], + description: '(8, 16)' + }, + { + str: '1234567890ABCDEF', + value: [0x90ABCDEF, 0x12345678], + description: '16' + }, + { + str: 'FFFFFFFFFFFFFFFF', + value: [0xFFFFFFFF, 0xFFFFFFFF], + description: '16 (max value)' + } + ]; + + describe('fromBytes', () => { + hexTestCases.forEach(testCase => { + it(`can parse byte array with ${testCase.description} significant digits`, () => { + // Arrange: prepare little-endian bytes + const bytes = convert.hexToUint8(testCase.str).reverse(); + + // Act: + const value = uint64.fromBytes(bytes); + + // Assert: + expect(value).to.deep.equal(testCase.value); + }); + }); + + it('cannot parse byte array with invalid size into uint64', () => { + // Arrange: + const errorMessage = 'byte array has unexpected size'; + + // Assert: + [0, 3, 4, 5, 7, 9].forEach(size => { + expect(() => { + uint64.fromBytes(new Uint8Array(size)); + }, `size ${size}`).to.throw(errorMessage); + }); + }); + }); + + describe('fromBytes32', () => { + const fromBytes32TestCases = [{ + str: '00000000', + value: [0, 0], + description: '0' + }, + { + str: '0000A1B2', + value: [0xA1B2, 0], + description: '(0, 8)' + }, + { + str: '12345678', + value: [0x12345678, 0], + description: '8' + }, + { + str: 'FFFFFFFF', + value: [0xFFFFFFFF, 0], + description: '8 (max value)' + } + ]; + + fromBytes32TestCases.forEach(testCase => { + it(`can parse byte array with ${testCase.description} significant digits`, () => { + // Arrange: prepare little-endian bytes + const bytes = convert.hexToUint8(testCase.str).reverse(); + + // Act: + const value = uint64.fromBytes32(bytes); + + // Assert: + expect(value).to.deep.equal(testCase.value); + }); + }); + + it('cannot parse byte array with invalid size into uint64', () => { + // Arrange: + const errorMessage = 'byte array has unexpected size'; + + // Assert: + [0, 3, 5, 7, 8, 9].forEach(size => { + expect(() => { + uint64.fromBytes32(new Uint8Array(size)); + }, `size ${size}`).to.throw(errorMessage); + }); + }); + }); + + describe('fromHex', () => { + hexTestCases.forEach(testCase => { + it(`can parse hex string with ${testCase.description} significant digits`, () => { + // Act: + const value = uint64.fromHex(testCase.str); + + // Assert: + expect(value).to.deep.equal(testCase.value); + }); + }); + + it('cannot parse hex string with invalid characters into uint64', () => { + // Assert: + expect(() => { + uint64.fromHex('0000000012345G78'); + }).to.throw('unrecognized hex char'); // contains 'G' + }); + + it('cannot parse hex string with invalid size into uint64', () => { + // Arrange: + const errorMessage = 'hex string has unexpected size'; + + // Assert: + expect(() => { + uint64.fromHex(''); + }).to.throw(errorMessage); // empty string + expect(() => { + uint64.fromHex('1'); + }).to.throw(errorMessage); // odd number of chars + expect(() => { + uint64.fromHex('ABCDEF12'); + }).to.throw(errorMessage); // too short + expect(() => { + uint64.fromHex('1234567890ABCDEF12'); + }).to.throw(errorMessage); // too long + }); + }); + + describe('toHex', () => { + hexTestCases.forEach(testCase => { + it(`can format hex string with ${testCase.description} significant digits`, () => { + // Act: + const str = uint64.toHex(testCase.value); + + // Assert: + expect(str).to.equal(testCase.str); + }); + }); + }); + + describe('isZero', () => { + const zeroTestCases = [{ + description: 'low and high are zero', + value: [0, 0], + isZero: true + }, + { + description: 'low is nonzero and high is zero', + value: [1, 0], + isZero: false + }, + { + description: 'low is zero and high is nonzero', + value: [0, 1], + isZero: false + }, + { + description: 'low and high are nonzero', + value: [74, 12], + isZero: false + } + ]; + + zeroTestCases.forEach(testCase => { + it(`returns ${testCase.isZero} when ${testCase.description}`, () => { + // Act: + const isZero = uint64.isZero(testCase.value); + + // Assert: + expect(isZero).to.equal(testCase.isZero); + }); + }); + }); +}); diff --git a/test/core/format/Utilities.spec.ts b/test/core/format/Utilities.spec.ts new file mode 100644 index 0000000000..26fa600e4a --- /dev/null +++ b/test/core/format/Utilities.spec.ts @@ -0,0 +1,146 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import * as utilities from '../../../src/core/format/Utilities'; + +describe('Char Mapping', () => { + describe('builder', () => { + it('initially has empty map', () => { + // Arrange: + const builder = utilities.createBuilder(); + + // Act: + const map = builder.map; + + // Assert: + expect(map).to.deep.equal({}); + }); + + it('can add single arbitrary range with zero base', () => { + // Arrange: + const builder = utilities.createBuilder(); + + // Act: + builder.addRange('d', 'f', 0); + const map = builder.map; + + // Assert: + expect(map).to.deep.equal({ + d: 0, + e: 1, + f: 2, + }); + }); + + it('can add single arbitrary range with nonzero base', () => { + // Arrange: + const builder = utilities.createBuilder(); + + // Act: + builder.addRange('d', 'f', 17); + const map = builder.map; + + // Assert: + expect(map).to.deep.equal({ + d: 17, + e: 18, + f: 19, + }); + }); + + it('can add multiple arbitrary ranges', () => { + // Arrange: + const builder = utilities.createBuilder(); + + // Act: + builder.addRange('b', 'b', 8); + builder.addRange('d', 'f', 17); + builder.addRange('y', 'z', 0); + const map = builder.map; + + // Assert: + expect(map).to.deep.equal({ + b: 8, + d: 17, + e: 18, + f: 19, + y: 0, + z: 1, + }); + }); + + it('can add multiple arbitrary overlapping ranges', () => { + // Arrange: + const builder = utilities.createBuilder(); + + // Act: + builder.addRange('b', 'b', 18); + builder.addRange('d', 'f', 17); + builder.addRange('y', 'z', 19); + const map = builder.map; + + // Assert: + expect(map).to.deep.equal({ + b: 18, + d: 17, + e: 18, + f: 19, + y: 19, + z: 20, + }); + }); + }); +}); + +describe('Convert', () => { + describe('tryParseUint', () => { + function addTryParseSuccessTest(name, str, expectedValue) { + it(name, () => { + // Act: + const value = utilities.tryParseUint(str); + + // Assert: + expect(value).to.equal(expectedValue); + }); + } + + addTryParseSuccessTest('can parse decimal string', '14952', 14952); + addTryParseSuccessTest('can parse zero decimal string', '0', 0); + addTryParseSuccessTest('can parse decimal string with all digits', '1234567890', 1234567890); + addTryParseSuccessTest('can parse decimal string with zeros', '10002', 10002); + addTryParseSuccessTest('can parse max safe integer decimal string', Number.MAX_SAFE_INTEGER.toString(), 9007199254740991); + + function addTryParseFailureTest(name, str) { + it(name, () => { + // Act: + const value = utilities.tryParseUint(str); + + // Assert: + expect(value).to.equal(undefined); + }); + } + + addTryParseFailureTest('cannot parse decimal string with left padding', ' 14952'); + addTryParseFailureTest('cannot parse decimal string with right padding', '14952 '); + addTryParseFailureTest('cannot parse decimal string too large', '9007199254740992'); + addTryParseFailureTest('cannot parse zeros string', '00'); + addTryParseFailureTest('cannot parse octal string', '0123'); + addTryParseFailureTest('cannot parse hex string', '0x14A52'); + addTryParseFailureTest('cannot parse double string', '14.52'); + addTryParseFailureTest('cannot parse negative decimal string', '-14952'); + addTryParseFailureTest('cannot parse arbitrary string', 'catapult'); + }); +}); diff --git a/test/core/utils/TransactionMapping.spec.ts b/test/core/utils/TransactionMapping.spec.ts index 0b1ca6bca8..c7bc986b01 100644 --- a/test/core/utils/TransactionMapping.spec.ts +++ b/test/core/utils/TransactionMapping.spec.ts @@ -17,7 +17,7 @@ import {deepEqual} from 'assert'; import { expect } from 'chai'; import { sha3_256 } from 'js-sha3'; -import { convert } from 'nem2-library'; +import {Convert as convert} from '../../../src/core/format'; import { TransactionMapping } from '../../../src/core/utils/TransactionMapping'; import { Account } from '../../../src/model/account/Account'; import { Address } from '../../../src/model/account/Address'; diff --git a/test/infrastructure/SerializeTransactionToJSON.spec.ts b/test/infrastructure/SerializeTransactionToJSON.spec.ts index 655e644a01..3c2d1bcdf9 100644 --- a/test/infrastructure/SerializeTransactionToJSON.spec.ts +++ b/test/infrastructure/SerializeTransactionToJSON.spec.ts @@ -16,7 +16,7 @@ import { expect } from 'chai'; import { sha3_256 } from 'js-sha3'; -import { convert } from 'nem2-library'; +import {Convert as convert} from '../../src/core/format'; import { Account } from '../../src/model/account/Account'; import { Address } from '../../src/model/account/Address'; import { PropertyModificationType } from '../../src/model/account/PropertyModificationType'; diff --git a/test/model/transaction/SecretLockTransaction.spec.ts b/test/model/transaction/SecretLockTransaction.spec.ts index 9795d7f5ae..26bbd11ede 100644 --- a/test/model/transaction/SecretLockTransaction.spec.ts +++ b/test/model/transaction/SecretLockTransaction.spec.ts @@ -17,7 +17,7 @@ import {deepEqual} from 'assert'; import {expect} from 'chai'; import * as CryptoJS from 'crypto-js'; import {keccak_256, sha3_256} from 'js-sha3'; -import {convert} from 'nem2-library'; +import {Convert as convert} from '../../../src/core/format'; import {Address} from '../../../src/model/account/Address'; import {NetworkType} from '../../../src/model/blockchain/NetworkType'; import {NetworkCurrencyMosaic} from '../../../src/model/mosaic/NetworkCurrencyMosaic'; diff --git a/test/model/transaction/SecretProofTransaction.spec.ts b/test/model/transaction/SecretProofTransaction.spec.ts index 12ccf662a0..6ee0b3aaab 100644 --- a/test/model/transaction/SecretProofTransaction.spec.ts +++ b/test/model/transaction/SecretProofTransaction.spec.ts @@ -16,7 +16,7 @@ import {expect} from 'chai'; import * as CryptoJS from 'crypto-js'; import {keccak_256, sha3_256} from 'js-sha3'; -import {convert} from 'nem2-library'; +import {Convert as convert} from '../../../src/core/format'; import { Account } from '../../../src/model/account/Account'; import {NetworkType} from '../../../src/model/blockchain/NetworkType'; import {Deadline} from '../../../src/model/transaction/Deadline'; From 6a24240532ebedc44ff6e7010c4055c14e78e809 Mon Sep 17 00:00:00 2001 From: Steven Liu Date: Tue, 11 Jun 2019 22:27:25 +0100 Subject: [PATCH 2/7] Added #94 Merged crypto implementation --- e2e/infrastructure/TransactionHttp.spec.ts | 27 +- index.ts | 1 + src/core/crypto/Crypto.ts | 318 ++++++++ src/core/crypto/KeyPair.ts | 74 ++ src/core/crypto/SHA3Hasher.ts | 70 ++ src/core/crypto/Utilities.ts | 227 ++++++ src/core/crypto/index.ts | 18 + src/core/crypto/nacl_catapult.ts | 852 +++++++++++++++++++++ src/model/account/Account.ts | 4 +- src/model/account/PublicAccount.ts | 2 +- src/model/model.ts | 1 + src/model/mosaic/MosaicNonce.ts | 6 +- src/model/transaction/EncryptedMessage.ts | 6 +- src/model/wallet/EncryptedPrivateKey.ts | 5 +- src/model/wallet/SimpleWallet.ts | 8 +- src/model/wallet/WalletAlgorithm.ts | 22 + 16 files changed, 1611 insertions(+), 30 deletions(-) create mode 100644 src/core/crypto/Crypto.ts create mode 100644 src/core/crypto/KeyPair.ts create mode 100644 src/core/crypto/SHA3Hasher.ts create mode 100644 src/core/crypto/Utilities.ts create mode 100644 src/core/crypto/index.ts create mode 100644 src/core/crypto/nacl_catapult.ts create mode 100644 src/model/wallet/WalletAlgorithm.ts diff --git a/e2e/infrastructure/TransactionHttp.spec.ts b/e2e/infrastructure/TransactionHttp.spec.ts index f27931a440..ce067eb5ea 100644 --- a/e2e/infrastructure/TransactionHttp.spec.ts +++ b/e2e/infrastructure/TransactionHttp.spec.ts @@ -17,7 +17,7 @@ import {assert, expect} from 'chai'; import * as CryptoJS from 'crypto-js'; import {ChronoUnit} from 'js-joda'; import {keccak_256, sha3_256} from 'js-sha3'; -import {nacl_catapult} from 'nem2-library'; +import {Crypto} from '../../src/core/crypto'; import { Convert as convert } from '../../src/core/format'; import {AccountHttp} from '../../src/infrastructure/AccountHttp'; import { NamespaceHttp } from '../../src/infrastructure/infrastructure'; @@ -67,7 +67,6 @@ import {Transaction} from '../../src/model/transaction/Transaction'; import {TransactionType} from '../../src/model/transaction/TransactionType'; import {TransferTransaction} from '../../src/model/transaction/TransferTransaction'; import {UInt64} from '../../src/model/UInt64'; - describe('TransactionHttp', () => { let transactionHash; let transactionId; @@ -993,7 +992,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Sha3_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1029,7 +1028,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Sha3_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1063,7 +1062,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Keccak_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1093,7 +1092,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Keccak_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1122,7 +1121,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('standalone', (done) => { - const secretSeed = String.fromCharCode.apply(null, nacl_catapult.randomBytes(20)); + const secretSeed = String.fromCharCode.apply(null, Crypto.randomBytes(20)); const secret = CryptoJS.RIPEMD160(CryptoJS.SHA256(secretSeed).toString(CryptoJS.enc.Hex)).toString(CryptoJS.enc.Hex); const secretLockTransaction = SecretLockTransaction.create( Deadline.create(), @@ -1154,7 +1153,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('aggregate', (done) => { - const secretSeed = String.fromCharCode.apply(null, nacl_catapult.randomBytes(20)); + const secretSeed = String.fromCharCode.apply(null, Crypto.randomBytes(20)); const secret = CryptoJS.RIPEMD160(CryptoJS.SHA256(secretSeed).toString(CryptoJS.enc.Hex)).toString(CryptoJS.enc.Hex); const secretLockTransaction = SecretLockTransaction.create( Deadline.create(), @@ -1195,7 +1194,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Hash_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1225,7 +1224,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Hash_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1254,7 +1253,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('standalone', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = sha3_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); @@ -1305,7 +1304,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('aggregate', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = sha3_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); const secretLockTransaction = SecretLockTransaction.create( @@ -1353,7 +1352,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('standalone', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = keccak_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); const secretLockTransaction = SecretLockTransaction.create( @@ -1397,7 +1396,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('aggregate', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = keccak_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); const secretLockTransaction = SecretLockTransaction.create( diff --git a/index.ts b/index.ts index 1146495f42..1239bbb0f5 100644 --- a/index.ts +++ b/index.ts @@ -19,3 +19,4 @@ export * from './src/model/model'; export * from './src/service/service'; export * from './src/core/utils/utility'; export * from './src/core/format'; +export * from './src/core/crypto'; diff --git a/src/core/crypto/Crypto.ts b/src/core/crypto/Crypto.ts new file mode 100644 index 0000000000..0deef4f151 --- /dev/null +++ b/src/core/crypto/Crypto.ts @@ -0,0 +1,318 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { WalletAlgorithm } from '../../model/wallet/WalletAlgorithm'; +import { Convert as convert } from '../format/Convert'; +import { KeyPair } from './KeyPair'; +import * as utility from './Utilities'; +const CryptoJS = require('crypto-js'); +export class Crypto { + /** + * Encrypt a private key for mobile apps (AES_PBKF2) + * + * @param {string} password - A wallet password + * @param {string} privateKey - An account private key + * + * @return {object} - The encrypted data + */ + public static toMobileKey = (password, privateKey) => { + // Errors + if (!password || !privateKey) { throw new Error('Missing argument !'); } + // Processing + const salt = CryptoJS.lib.WordArray.random(256 / 8); + const key = CryptoJS.PBKDF2(password, salt, { + keySize: 256 / 32, + iterations: 2000, + }); + const iv = Crypto.randomBytes(16); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = CryptoJS.AES.encrypt(CryptoJS.enc.Hex.parse(privateKey), key, encIv); + // Result + return { + encrypted: convert.uint8ToHex(iv) + encrypted.ciphertext, + salt: salt.toString(), + }; + } + + /** + * Derive a private key from a password using count iterations of SHA3-256 + * + * @param {string} password - A wallet password + * @param {number} count - A number of iterations above 0 + * + * @return {object} - The derived private key + */ + public static derivePassSha = (password, count) => { + // Errors + if (!password) { throw new Error('Missing argument !'); } + if (!count || count <= 0) { throw new Error('Please provide a count number above 0'); } + // Processing + let data = password; + for (let i = 0; i < count; ++i) { + data = CryptoJS.SHA3(data, { + outputLength: 256, + }); + } + // Result + return { + priv: CryptoJS.enc.Hex.stringify(data), + }; + } + + /** + * Encrypt hex data using a key + * + * @param {string} data - An hex string + * @param {Uint8Array} key - An Uint8Array key + * + * @return {object} - The encrypted data + */ + public static encrypt = (data, key) => { + // Errors + if (!data || !key) { throw new Error('Missing argument !'); } + // Processing + const iv = Crypto.randomBytes(16); + const encKey = utility.ua2words(key, 32); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = CryptoJS.AES.encrypt(CryptoJS.enc.Hex.parse(data), encKey, encIv); + // Result + return { + ciphertext: encrypted.ciphertext, + iv, + key, + }; + } + + /** + * Decrypt data + * + * @param {object} data - An encrypted data object + * + * @return {string} - The decrypted hex string + */ + public static decrypt = (data) => { + // Errors + if (!data) { throw new Error('Missing argument !'); } + // Processing + const encKey = utility.ua2words(data.key, 32); + const encIv = { + iv: utility.ua2words(data.iv, 16), + }; + // Result + return CryptoJS.enc.Hex.stringify(CryptoJS.AES.decrypt(data, encKey, encIv)); + } + + /** + * Reveal the private key of an account or derive it from the wallet password + * + * @param {object} common- An object containing password and privateKey field + * @param {object} walletAccount - A wallet account object + * @param {WalletAlgorithm} algo - A wallet algorithm + * + * @return {object|boolean} - The account private key in and object or false + */ + public static passwordToPrivateKey = (common, walletAccount, algo) => { + // Errors + if (!common || !common.password || !walletAccount || !algo) { throw new Error('Missing argument !'); } + // Processing + let r; + if (algo === WalletAlgorithm.Pass_6k) { // Brain wallets + if (!walletAccount.encrypted && !walletAccount.iv) { + // Account private key is generated simply using a passphrase so it has no encrypted and iv + r = Crypto.derivePassSha(common.password, 6000); + } else if (!walletAccount.encrypted || !walletAccount.iv) { + // Else if one is missing there is a problem + return false; + } else { + // Else child accounts have encrypted and iv so we decrypt + const pass = Crypto.derivePassSha(common.password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(walletAccount.encrypted), + iv: convert.hexToUint8(walletAccount.iv), + key: convert.hexToUint8(pass.priv), + }; + const d = Crypto.decrypt(obj); + r = { priv: d }; + } + } else if (algo === WalletAlgorithm.Pass_bip32) { // Wallets from PRNG + const pass = Crypto.derivePassSha(common.password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(walletAccount.encrypted), + iv: convert.hexToUint8(walletAccount.iv), + key: convert.hexToUint8(pass.priv), + }; + const d = Crypto.decrypt(obj); + r = { priv: d }; + } else if (algo === WalletAlgorithm.Pass_enc) { // Private Key wallets + const pass = Crypto.derivePassSha(common.password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(walletAccount.encrypted), + iv: convert.hexToUint8(walletAccount.iv), + key: convert.hexToUint8(pass.priv), + }; + const d = Crypto.decrypt(obj); + r = { priv: d }; + } else if (algo === WalletAlgorithm.Trezor) { // HW wallet + r = { priv: '' }; + common.isHW = true; + } else { + return false; + } + // Result + common.privateKey = r.priv; + return true; + } + + /** + * Generate a random key + * + * @return {Uint8Array} - A random key + */ + public static randomKey = () => { + return Crypto.randomBytes(32); + } + + /** + * Encode a private key using a password + * + * @param {string} privateKey - An hex private key + * @param {string} password - A password + * + * @return {object} - The encoded data + */ + public static encodePrivateKey = (privateKey, password) => { + // Errors + if (!privateKey || !password) { throw new Error('Missing argument !'); } + // Processing + const pass = Crypto.derivePassSha(password, 20); + const r = Crypto.encrypt(privateKey, convert.hexToUint8(pass.priv)); + // Result + return { + ciphertext: CryptoJS.enc.Hex.stringify(r.ciphertext), + iv: convert.uint8ToHex(r.iv), + }; + } + + /*** + * Encode a message, separated from encode() to help testing + * + * @param {string} senderPriv - A sender private key + * @param {string} recipientPub - A recipient public key + * @param {string} msg - A text message + * @param {Uint8Array} iv - An initialization vector + * @param {Uint8Array} salt - A salt + * + * @return {string} - The encoded message + */ + public static _encode = function(senderPriv, recipientPub, msg, iv, salt) { + // Errors + if (!senderPriv || !recipientPub || !msg || !iv || !salt) { throw new Error('Missing argument !'); } + // Processing + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(senderPriv); + const pk = convert.hexToUint8(recipientPub); + const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt), 32); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = CryptoJS.AES.encrypt(CryptoJS.enc.Hex.parse(convert.utf8ToHex(msg)), encKey, encIv); + // Result + const result = convert.uint8ToHex(salt) + convert.uint8ToHex(iv) + CryptoJS.enc.Hex.stringify(encrypted.ciphertext); + return result; + } + + /** + * Encode a message + * + * @param {string} senderPriv - A sender private key + * @param {string} recipientPub - A recipient public key + * @param {string} msg - A text message + * + * @return {string} - The encoded message + */ + public static encode = (senderPriv, recipientPub, msg) => { + // Errors + if (!senderPriv || !recipientPub || !msg) { throw new Error('Missing argument !'); } + // Processing + const iv = Crypto.randomBytes(16); + const salt = Crypto.randomBytes(32); + const encoded = Crypto._encode(senderPriv, recipientPub, msg, iv, salt); + // Result + return encoded; + } + + /** + * Decode an encrypted message payload + * + * @param {string} recipientPrivate - A recipient private key + * @param {string} senderPublic - A sender public key + * @param {Uint8Array} _payload - An encrypted message payload in bytes + * + * @return {string} - The decoded payload as hex + */ + public static _decode = (recipientPrivate, senderPublic, payload, iv, salt) => { + // Error + if (!recipientPrivate || !senderPublic || !payload) { throw new Error('Missing argument !'); } + // Processing + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(recipientPrivate); + const pk = convert.hexToUint8(senderPublic); + const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt), 32); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = { + ciphertext: utility.ua2words(payload, payload.length), + }; + const plain = CryptoJS.AES.decrypt(encrypted, encKey, encIv); + // Result + return CryptoJS.enc.Hex.stringify(plain); + } + + /** + * Decode an encrypted message payload + * + * @param {string} recipientPrivate - A recipient private key + * @param {string} senderPublic - A sender public key + * @param {string} _payload - An encrypted message payload + * + * @return {string} - The decoded payload as hex + */ + public static decode = (recipientPrivate, senderPublic, _payload) => { + // Error + if (!recipientPrivate || !senderPublic || !_payload) { throw new Error('Missing argument !'); } + // Processing + const binPayload = convert.hexToUint8(_payload); + const payload = new Uint8Array(binPayload.buffer, 48); + const salt = new Uint8Array(binPayload.buffer, 0, 32); + const iv = new Uint8Array(binPayload.buffer, 32, 16); + const decoded = Crypto._decode(recipientPrivate, senderPublic, payload, iv, salt); + return decoded; + } + + /** + * Generate random bytes by length + * @param {number} length - The length of the random bytes + * + * @return {Uint8Array} + */ + public static randomBytes = (length) => { + const crypto = require('crypto'); + return crypto.randomBytes(length); + } +} diff --git a/src/core/crypto/KeyPair.ts b/src/core/crypto/KeyPair.ts new file mode 100644 index 0000000000..b2b5a1bd1b --- /dev/null +++ b/src/core/crypto/KeyPair.ts @@ -0,0 +1,74 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { Convert as convert } from '../format'; +import * as Utility from './Utilities'; + +export class KeyPair { + /** + * Creates a key pair from a private key string. + * @param {string} privateKeyString A hex encoded private key string. + * @returns {module:crypto/keyPair~KeyPair} The key pair. + */ + public static createKeyPairFromPrivateKeyString = (privateKeyString) => { + const privateKey = convert.hexToUint8(privateKeyString); + if (Utility.Key_Size !== privateKey.length) { + throw Error(`private key has unexpected size: ${privateKey.length}`); + } + + const publicKey = Utility.catapult_crypto.extractPublicKey(privateKey, Utility.catapult_hash.func); + return { + privateKey, + publicKey, + }; + } + + /** + * Signs a data buffer with a key pair. + * @param {module:crypto/keyPair~KeyPair} keyPair The key pair to use for signing. + * @param {Uint8Array} data The data to sign. + * @returns {Uint8Array} The signature. + */ + public static sign = (keyPair, data) => { + return Utility.catapult_crypto.sign(data, keyPair.publicKey, keyPair.privateKey, Utility.catapult_hash.createHasher()); + } + + /** + * Verifies a signature. + * @param {module:crypto/keyPair~PublicKey} publicKey The public key to use for verification. + * @param {Uint8Array} data The data to verify. + * @param {Uint8Array} signature The signature to verify. + * @returns {boolean} true if the signature is verifiable, false otherwise. + */ + public static verify = (publicKey, data, signature) => { + return Utility.catapult_crypto.verify(publicKey, data, signature, Utility.catapult_hash.createHasher()); + } + + /** + * Creates a shared key given a key pair and an arbitrary public key. + * The shared key can be used for encrypted message passing between the two. + * @param {module:crypto/keyPair~KeyPair} keyPair The key pair for which to create the shared key. + * @param {module:crypto/keyPair~PublicKey} publicKey The public key for which to create the shared key. + * @param {Uint8Array} salt A salt that should be applied to the shared key. + * @returns {Uint8Array} The shared key. + */ + public static deriveSharedKey = (keyPair, publicKey, salt) => { + if (Utility.Key_Size !== salt.length) { + throw Error(`salt has unexpected size: ${salt.length}`); + } + + return Utility.catapult_crypto.deriveSharedKey(salt, keyPair.privateKey, publicKey, Utility.catapult_hash.func); + } +} diff --git a/src/core/crypto/SHA3Hasher.ts b/src/core/crypto/SHA3Hasher.ts new file mode 100644 index 0000000000..28ecc06847 --- /dev/null +++ b/src/core/crypto/SHA3Hasher.ts @@ -0,0 +1,70 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { sha3_256, sha3_512 } from 'js-sha3'; +import { Convert as convert, RawArray as array } from '../format'; + +export class SHA3Hasher { + /** + * Calculates the hash of data. + * @param {Uint8Array} dest The computed hash destination. + * @param {Uint8Array} data The data to hash. + * @param {numeric} length The hash length in bytes. + */ + public static func = (dest, data, length) => { + const hasher = SHA3Hasher.getHasher(length); + const hash = hasher.arrayBuffer(data); + array.copy(dest, array.uint8View(hash)); + } + + /** + * Creates a hasher object. + * @param {numeric} length The hash length in bytes. + * @returns {object} The hasher. + */ + public static createHasher = (length = 64) => { + let hash; + return { + reset: () => { + hash = SHA3Hasher.getHasher(length).create(); + }, + update: (data: any) => { + if (data instanceof Uint8Array) { + hash.update(data); + } else if ('string' === typeof data) { + hash.update(convert.hexToUint8(data)); + } else { + throw Error('unsupported data type'); + } + }, + finalize: (result: any) => { + array.copy(result, array.uint8View(hash.arrayBuffer())); + }, + }; + } + + /** + * Get a hasher instance. + * @param {numeric} length The hash length in bytes. + * @returns {object} The hasher. + */ + public static getHasher = (length = 64) => { + return { + 32: sha3_256, + 64: sha3_512, + } [length]; + } +} diff --git a/src/core/crypto/Utilities.ts b/src/core/crypto/Utilities.ts new file mode 100644 index 0000000000..487df065f7 --- /dev/null +++ b/src/core/crypto/Utilities.ts @@ -0,0 +1,227 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { RawArray as array } from '../format'; +import * as nacl from './nacl_catapult'; +import { SHA3Hasher as sha3Hasher } from './SHA3Hasher'; + +export const CryptoJS = require('crypto-js'); +export const Key_Size = 32; +export const Signature_Size = 64; +export const Half_Signature_Size = Signature_Size / 2; +export const Hash_Size = 64; +export const Half_Hash_Size = Hash_Size / 2; + +/** + * Convert an Uint8Array to WordArray + * + * @param {Uint8Array} ua - An Uint8Array + * @param {number} uaLength - The Uint8Array length + * + * @return {WordArray} + */ +export const ua2words = (ua, uaLength) => { + const temp: number[] = []; + for (let i = 0; i < uaLength; i += 4) { + const x = ua[i] * 0x1000000 + (ua[i + 1] || 0) * 0x10000 + (ua[i + 2] || 0) * 0x100 + (ua[i + 3] || 0); + temp.push((x > 0x7fffffff) ? x - 0x100000000 : x); + } + return CryptoJS.lib.WordArray.create(temp, uaLength); +}; + +/** + * Convert a wordArray to Uint8Array + * + * @param {Uint8Array} destUa - A destination Uint8Array + * @param {WordArray} cryptoWords - A wordArray + * + * @return {Uint8Array} + */ +export const words2ua = (destUa, cryptoWords) => { + for (let i = 0; i < destUa.length; i += 4) { + let v = cryptoWords.words[i / 4]; + if (v < 0) { v += 0x100000000; } + destUa[i] = (v >>> 24); + destUa[i + 1] = (v >>> 16) & 0xff; + destUa[i + 2] = (v >>> 8) & 0xff; + destUa[i + 3] = v & 0xff; + } + return destUa; +}; + +export const catapult_hash = { + func: sha3Hasher.func, + createHasher: sha3Hasher.createHasher, +}; + +// custom catapult crypto functions +export const catapult_crypto = (function() { + function clamp(d) { + d[0] &= 248; + d[31] &= 127; + d[31] |= 64; + } + + function prepareForScalarMult(sk, hashfunc) { + const d = new Uint8Array(Hash_Size); + hashfunc(d, sk); + clamp(d); + return d; + } + + const encodedSChecker = (function() { + const Is_Reduced = 1; + const Is_Zero = 2; + + function validateEncodedSPart(s) { + if (array.isZeroFilled(s)) { + return Is_Zero | Is_Reduced; + } + const copy = new Uint8Array(Signature_Size); + array.copy(copy, s, Half_Signature_Size); + + nacl.reduce(copy); + return array.deepEqual(s, copy, Half_Signature_Size) ? Is_Reduced : 0; + } + + return { + isCanonical: (s) => Is_Reduced === validateEncodedSPart(s), + + requireValid: (s) => { + if (0 === (validateEncodedSPart(s) & Is_Reduced)) { + throw Error('S part of signature invalid'); + } + }, + }; + })(); + + return { + extractPublicKey: (sk, hashfunc) => { + const c = nacl; + const d = prepareForScalarMult(sk, hashfunc); + + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const pk = new Uint8Array(Key_Size); + c.scalarbase(p, d); + c.pack(pk, p); + return pk; + }, + + sign: (m, pk, sk, hasher) => { + const c = nacl; + + const d = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(sk); + hasher.finalize(d); + clamp(d); + + const r = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(d.subarray(Half_Hash_Size)); + hasher.update(m); + hasher.finalize(r); + + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const signature = new Uint8Array(Signature_Size); + c.reduce(r); + c.scalarbase(p, r); + c.pack(signature, p); + + const h = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(signature.subarray(0, Half_Signature_Size)); + hasher.update(pk); + hasher.update(m); + hasher.finalize(h); + + c.reduce(h); + + // muladd + const x = new Float64Array(Hash_Size); + array.copy(x, r, Half_Hash_Size); + + for (let i = 0; i < Half_Hash_Size; ++i) { + for (let j = 0; j < Half_Hash_Size; ++j) { + x[i + j] += h[i] * d[j]; + } + } + + c.modL(signature.subarray(Half_Signature_Size), x); + encodedSChecker.requireValid(signature.subarray(Half_Signature_Size)); + return signature; + }, + + verify: (pk, m, signature, hasher) => { + // reject non canonical signature + if (!encodedSChecker.isCanonical(signature.subarray(Half_Signature_Size))) { + return false; + } + + // reject weak (zero) public key + if (array.isZeroFilled(pk)) { + return false; + } + + const c = nacl; + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const q = [c.gf(), c.gf(), c.gf(), c.gf()]; + + if (c.unpackneg(q, pk)) { + return false; + } + + const h = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(signature.subarray(0, Half_Signature_Size)); + hasher.update(pk); + hasher.update(m); + hasher.finalize(h); + + c.reduce(h); + c.scalarmult(p, q, h); + + const t = new Uint8Array(Signature_Size); + c.scalarbase(q, signature.subarray(Half_Signature_Size)); + c.add(p, q); + c.pack(t, p); + + return 0 === c.crypto_verify_32(signature, 0, t, 0); + }, + + deriveSharedKey: (salt, sk, pk, hashfunc) => { + const c = nacl; + const d = prepareForScalarMult(sk, hashfunc); + + // sharedKey = pack(p = d (derived from sk) * q (derived from pk)) + const q = [c.gf(), c.gf(), c.gf(), c.gf()]; + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const sharedKey = new Uint8Array(Key_Size); + c.unpackneg(q, pk); + c.scalarmult(p, q, d); + c.pack(sharedKey, p); + + // salt the shared key + for (let i = 0; i < Key_Size; ++i) { + sharedKey[i] ^= salt[i]; + } + + // return the hash of the result + const sharedKeyHash = new Uint8Array(Key_Size); + hashfunc(sharedKeyHash, sharedKey, Key_Size); + return sharedKeyHash; + }, + }; +})(); diff --git a/src/core/crypto/index.ts b/src/core/crypto/index.ts new file mode 100644 index 0000000000..1a168b4094 --- /dev/null +++ b/src/core/crypto/index.ts @@ -0,0 +1,18 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export * from './Crypto'; +export * from './KeyPair'; diff --git a/src/core/crypto/nacl_catapult.ts b/src/core/crypto/nacl_catapult.ts new file mode 100644 index 0000000000..1d47ac02fe --- /dev/null +++ b/src/core/crypto/nacl_catapult.ts @@ -0,0 +1,852 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// README: This is copied from tweeetnacl/nacl.fast.js and is updated to export custom hash functions. + +// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri. +// Public domain. +// +// Implementation derived from TweetNaCl version 20140427. +// See for details: http://tweetnacl.cr.yp.to/ +const _0 = new Uint8Array(16); +const _9 = new Uint8Array(32); +_9[0] = 9; + +export const gf = (init ? ) => { + // tslint:disable-next-line:one-variable-per-declaration + let i; + const r = new Float64Array(16); + if (init) { + for (i = 0; i < init.length; i++) { + r[i] = init[i]; + } + } + return r; +}; + +// tslint:disable-next-line:one-variable-per-declaration +const gf0 = gf(), + gf1 = gf([1]), + _121665 = gf([0xdb41, 1]), + D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, + 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203 + ]), + D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, + 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406 + ]), + X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, + 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169 + ]), + Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, + 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666 + ]), + I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, + 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83 + ]); +const L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, + 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10 +]); + +const A = (o, a, b) => { + for (let i = 0; i < 16; i++) { + o[i] = a[i] + b[i]; + } +}; + +const Z = (o, a, b) => { + for (let i = 0; i < 16; i++) { + o[i] = a[i] - b[i]; + } +}; + +const M = (o, a, b) => { + // tslint:disable-next-line:one-variable-per-declaration + let v, c, + t0 = 0, + t1 = 0, + t2 = 0, + t3 = 0, + t4 = 0, + t5 = 0, + t6 = 0, + t7 = 0, + t8 = 0, + t9 = 0, + t10 = 0, + t11 = 0, + t12 = 0, + t13 = 0, + t14 = 0, + t15 = 0, + t16 = 0, + t17 = 0, + t18 = 0, + t19 = 0, + t20 = 0, + t21 = 0, + t22 = 0, + t23 = 0, + t24 = 0, + t25 = 0, + t26 = 0, + t27 = 0, + t28 = 0, + t29 = 0, + t30 = 0, + b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3], + b4 = b[4], + b5 = b[5], + b6 = b[6], + b7 = b[7], + b8 = b[8], + b9 = b[9], + b10 = b[10], + b11 = b[11], + b12 = b[12], + b13 = b[13], + b14 = b[14], + b15 = b[15]; + + v = a[0]; + t0 += v * b0; + t1 += v * b1; + t2 += v * b2; + t3 += v * b3; + t4 += v * b4; + t5 += v * b5; + t6 += v * b6; + t7 += v * b7; + t8 += v * b8; + t9 += v * b9; + t10 += v * b10; + t11 += v * b11; + t12 += v * b12; + t13 += v * b13; + t14 += v * b14; + t15 += v * b15; + v = a[1]; + t1 += v * b0; + t2 += v * b1; + t3 += v * b2; + t4 += v * b3; + t5 += v * b4; + t6 += v * b5; + t7 += v * b6; + t8 += v * b7; + t9 += v * b8; + t10 += v * b9; + t11 += v * b10; + t12 += v * b11; + t13 += v * b12; + t14 += v * b13; + t15 += v * b14; + t16 += v * b15; + v = a[2]; + t2 += v * b0; + t3 += v * b1; + t4 += v * b2; + t5 += v * b3; + t6 += v * b4; + t7 += v * b5; + t8 += v * b6; + t9 += v * b7; + t10 += v * b8; + t11 += v * b9; + t12 += v * b10; + t13 += v * b11; + t14 += v * b12; + t15 += v * b13; + t16 += v * b14; + t17 += v * b15; + v = a[3]; + t3 += v * b0; + t4 += v * b1; + t5 += v * b2; + t6 += v * b3; + t7 += v * b4; + t8 += v * b5; + t9 += v * b6; + t10 += v * b7; + t11 += v * b8; + t12 += v * b9; + t13 += v * b10; + t14 += v * b11; + t15 += v * b12; + t16 += v * b13; + t17 += v * b14; + t18 += v * b15; + v = a[4]; + t4 += v * b0; + t5 += v * b1; + t6 += v * b2; + t7 += v * b3; + t8 += v * b4; + t9 += v * b5; + t10 += v * b6; + t11 += v * b7; + t12 += v * b8; + t13 += v * b9; + t14 += v * b10; + t15 += v * b11; + t16 += v * b12; + t17 += v * b13; + t18 += v * b14; + t19 += v * b15; + v = a[5]; + t5 += v * b0; + t6 += v * b1; + t7 += v * b2; + t8 += v * b3; + t9 += v * b4; + t10 += v * b5; + t11 += v * b6; + t12 += v * b7; + t13 += v * b8; + t14 += v * b9; + t15 += v * b10; + t16 += v * b11; + t17 += v * b12; + t18 += v * b13; + t19 += v * b14; + t20 += v * b15; + v = a[6]; + t6 += v * b0; + t7 += v * b1; + t8 += v * b2; + t9 += v * b3; + t10 += v * b4; + t11 += v * b5; + t12 += v * b6; + t13 += v * b7; + t14 += v * b8; + t15 += v * b9; + t16 += v * b10; + t17 += v * b11; + t18 += v * b12; + t19 += v * b13; + t20 += v * b14; + t21 += v * b15; + v = a[7]; + t7 += v * b0; + t8 += v * b1; + t9 += v * b2; + t10 += v * b3; + t11 += v * b4; + t12 += v * b5; + t13 += v * b6; + t14 += v * b7; + t15 += v * b8; + t16 += v * b9; + t17 += v * b10; + t18 += v * b11; + t19 += v * b12; + t20 += v * b13; + t21 += v * b14; + t22 += v * b15; + v = a[8]; + t8 += v * b0; + t9 += v * b1; + t10 += v * b2; + t11 += v * b3; + t12 += v * b4; + t13 += v * b5; + t14 += v * b6; + t15 += v * b7; + t16 += v * b8; + t17 += v * b9; + t18 += v * b10; + t19 += v * b11; + t20 += v * b12; + t21 += v * b13; + t22 += v * b14; + t23 += v * b15; + v = a[9]; + t9 += v * b0; + t10 += v * b1; + t11 += v * b2; + t12 += v * b3; + t13 += v * b4; + t14 += v * b5; + t15 += v * b6; + t16 += v * b7; + t17 += v * b8; + t18 += v * b9; + t19 += v * b10; + t20 += v * b11; + t21 += v * b12; + t22 += v * b13; + t23 += v * b14; + t24 += v * b15; + v = a[10]; + t10 += v * b0; + t11 += v * b1; + t12 += v * b2; + t13 += v * b3; + t14 += v * b4; + t15 += v * b5; + t16 += v * b6; + t17 += v * b7; + t18 += v * b8; + t19 += v * b9; + t20 += v * b10; + t21 += v * b11; + t22 += v * b12; + t23 += v * b13; + t24 += v * b14; + t25 += v * b15; + v = a[11]; + t11 += v * b0; + t12 += v * b1; + t13 += v * b2; + t14 += v * b3; + t15 += v * b4; + t16 += v * b5; + t17 += v * b6; + t18 += v * b7; + t19 += v * b8; + t20 += v * b9; + t21 += v * b10; + t22 += v * b11; + t23 += v * b12; + t24 += v * b13; + t25 += v * b14; + t26 += v * b15; + v = a[12]; + t12 += v * b0; + t13 += v * b1; + t14 += v * b2; + t15 += v * b3; + t16 += v * b4; + t17 += v * b5; + t18 += v * b6; + t19 += v * b7; + t20 += v * b8; + t21 += v * b9; + t22 += v * b10; + t23 += v * b11; + t24 += v * b12; + t25 += v * b13; + t26 += v * b14; + t27 += v * b15; + v = a[13]; + t13 += v * b0; + t14 += v * b1; + t15 += v * b2; + t16 += v * b3; + t17 += v * b4; + t18 += v * b5; + t19 += v * b6; + t20 += v * b7; + t21 += v * b8; + t22 += v * b9; + t23 += v * b10; + t24 += v * b11; + t25 += v * b12; + t26 += v * b13; + t27 += v * b14; + t28 += v * b15; + v = a[14]; + t14 += v * b0; + t15 += v * b1; + t16 += v * b2; + t17 += v * b3; + t18 += v * b4; + t19 += v * b5; + t20 += v * b6; + t21 += v * b7; + t22 += v * b8; + t23 += v * b9; + t24 += v * b10; + t25 += v * b11; + t26 += v * b12; + t27 += v * b13; + t28 += v * b14; + t29 += v * b15; + v = a[15]; + t15 += v * b0; + t16 += v * b1; + t17 += v * b2; + t18 += v * b3; + t19 += v * b4; + t20 += v * b5; + t21 += v * b6; + t22 += v * b7; + t23 += v * b8; + t24 += v * b9; + t25 += v * b10; + t26 += v * b11; + t27 += v * b12; + t28 += v * b13; + t29 += v * b14; + t30 += v * b15; + + t0 += 38 * t16; + t1 += 38 * t17; + t2 += 38 * t18; + t3 += 38 * t19; + t4 += 38 * t20; + t5 += 38 * t21; + t6 += 38 * t22; + t7 += 38 * t23; + t8 += 38 * t24; + t9 += 38 * t25; + t10 += 38 * t26; + t11 += 38 * t27; + t12 += 38 * t28; + t13 += 38 * t29; + t14 += 38 * t30; + // t15 left as is + + // first car + c = 1; + v = t0 + c + 65535; + c = Math.floor(v / 65536); + t0 = v - c * 65536; + v = t1 + c + 65535; + c = Math.floor(v / 65536); + t1 = v - c * 65536; + v = t2 + c + 65535; + c = Math.floor(v / 65536); + t2 = v - c * 65536; + v = t3 + c + 65535; + c = Math.floor(v / 65536); + t3 = v - c * 65536; + v = t4 + c + 65535; + c = Math.floor(v / 65536); + t4 = v - c * 65536; + v = t5 + c + 65535; + c = Math.floor(v / 65536); + t5 = v - c * 65536; + v = t6 + c + 65535; + c = Math.floor(v / 65536); + t6 = v - c * 65536; + v = t7 + c + 65535; + c = Math.floor(v / 65536); + t7 = v - c * 65536; + v = t8 + c + 65535; + c = Math.floor(v / 65536); + t8 = v - c * 65536; + v = t9 + c + 65535; + c = Math.floor(v / 65536); + t9 = v - c * 65536; + v = t10 + c + 65535; + c = Math.floor(v / 65536); + t10 = v - c * 65536; + v = t11 + c + 65535; + c = Math.floor(v / 65536); + t11 = v - c * 65536; + v = t12 + c + 65535; + c = Math.floor(v / 65536); + t12 = v - c * 65536; + v = t13 + c + 65535; + c = Math.floor(v / 65536); + t13 = v - c * 65536; + v = t14 + c + 65535; + c = Math.floor(v / 65536); + t14 = v - c * 65536; + v = t15 + c + 65535; + c = Math.floor(v / 65536); + t15 = v - c * 65536; + t0 += c - 1 + 37 * (c - 1); + + // second car + c = 1; + v = t0 + c + 65535; + c = Math.floor(v / 65536); + t0 = v - c * 65536; + v = t1 + c + 65535; + c = Math.floor(v / 65536); + t1 = v - c * 65536; + v = t2 + c + 65535; + c = Math.floor(v / 65536); + t2 = v - c * 65536; + v = t3 + c + 65535; + c = Math.floor(v / 65536); + t3 = v - c * 65536; + v = t4 + c + 65535; + c = Math.floor(v / 65536); + t4 = v - c * 65536; + v = t5 + c + 65535; + c = Math.floor(v / 65536); + t5 = v - c * 65536; + v = t6 + c + 65535; + c = Math.floor(v / 65536); + t6 = v - c * 65536; + v = t7 + c + 65535; + c = Math.floor(v / 65536); + t7 = v - c * 65536; + v = t8 + c + 65535; + c = Math.floor(v / 65536); + t8 = v - c * 65536; + v = t9 + c + 65535; + c = Math.floor(v / 65536); + t9 = v - c * 65536; + v = t10 + c + 65535; + c = Math.floor(v / 65536); + t10 = v - c * 65536; + v = t11 + c + 65535; + c = Math.floor(v / 65536); + t11 = v - c * 65536; + v = t12 + c + 65535; + c = Math.floor(v / 65536); + t12 = v - c * 65536; + v = t13 + c + 65535; + c = Math.floor(v / 65536); + t13 = v - c * 65536; + v = t14 + c + 65535; + c = Math.floor(v / 65536); + t14 = v - c * 65536; + v = t15 + c + 65535; + c = Math.floor(v / 65536); + t15 = v - c * 65536; + t0 += c - 1 + 37 * (c - 1); + + o[0] = t0; + o[1] = t1; + o[2] = t2; + o[3] = t3; + o[4] = t4; + o[5] = t5; + o[6] = t6; + o[7] = t7; + o[8] = t8; + o[9] = t9; + o[10] = t10; + o[11] = t11; + o[12] = t12; + o[13] = t13; + o[14] = t14; + o[15] = t15; +}; + +const S = (o, a) => { + M(o, a, a); +}; +const vn = (x, xi, y, yi, n) => { + // tslint:disable-next-line:one-variable-per-declaration + let i, d = 0; + for (i = 0; i < n; i++) { + d |= x[xi + i] ^ y[yi + i]; + } + return (1 & ((d - 1) >>> 8)) - 1; +}; + +const pow2523 = (o, i) => { + const c = gf(); + let a; + for (a = 0; a < 16; a++) { + c[a] = i[a]; + } + for (a = 250; a >= 0; a--) { + S(c, c); + if (a !== 1) { + M(c, c, i); + } + } + for (a = 0; a < 16; a++) { + o[a] = c[a]; + } +}; +const inv25519 = (o, i) => { + const c = gf(); + let a; + for (a = 0; a < 16; a++) { + c[a] = i[a]; + } + for (a = 253; a >= 0; a--) { + S(c, c); + if (a !== 2 && a !== 4) { + M(c, c, i); + } + } + for (a = 0; a < 16; a++) { + o[a] = c[a]; + } +}; +const set25519 = (r, a) => { + let i; + for (i = 0; i < 16; i++) { + r[i] = a[i] | 0; + } +}; + +const car25519 = (o) => { + // tslint:disable-next-line:one-variable-per-declaration + let i, v, c = 1; + for (i = 0; i < 16; i++) { + v = o[i] + c + 65535; + c = Math.floor(v / 65536); + o[i] = v - c * 65536; + } + o[0] += c - 1 + 37 * (c - 1); +}; + +const sel25519 = (p, q, b) => { + // tslint:disable-next-line:one-variable-per-declaration + let t, c = ~(b - 1); + for (let i = 0; i < 16; i++) { + t = c & (p[i] ^ q[i]); + p[i] ^= t; + q[i] ^= t; + } +}; + +const pack25519 = (o, n) => { + // tslint:disable-next-line:one-variable-per-declaration + let i, j, b; + // tslint:disable-next-line:one-variable-per-declaration + const m = gf(), + t = gf(); + for (i = 0; i < 16; i++) { + t[i] = n[i]; + } + car25519(t); + car25519(t); + car25519(t); + for (j = 0; j < 2; j++) { + m[0] = t[0] - 0xffed; + for (i = 1; i < 15; i++) { + m[i] = t[i] - 0xffff - ((m[i - 1] >> 16) & 1); + m[i - 1] &= 0xffff; + } + m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1); + b = (m[15] >> 16) & 1; + m[14] &= 0xffff; + sel25519(t, m, 1 - b); + } + for (i = 0; i < 16; i++) { + o[2 * i] = t[i] & 0xff; + o[2 * i + 1] = t[i] >> 8; + } +}; + +const cswap = (p, q, b) => { + let i; + for (i = 0; i < 4; i++) { + sel25519(p[i], q[i], b); + } +}; + +const neq25519 = (a, b) => { + // tslint:disable-next-line:one-variable-per-declaration + const c = new Uint8Array(32), + d = new Uint8Array(32); + pack25519(c, a); + pack25519(d, b); + return crypto_verify_32(c, 0, d, 0); +}; + +const par25519 = (a) => { + const d = new Uint8Array(32); + pack25519(d, a); + return d[0] & 1; +}; + +const unpack25519 = (o, n) => { + let i; + for (i = 0; i < 16; i++) { + o[i] = n[2 * i] + (n[2 * i + 1] << 8); + } + o[15] &= 0x7fff; +}; + +export const cleanup = (arr) => { + for (var i = 0; i < arr.length; i++) { + arr[i] = 0; + } +}; + +export const crypto_shared_key_hash = (shared, pk, sk, hashfunc) => { + const d = new Uint8Array(64); + const p = [gf(), gf(), gf(), gf()]; + + hashfunc(d, sk, 32); + d[0] &= 248; + d[31] &= 127; + d[31] |= 64; + + let q = [gf(), gf(), gf(), gf()]; + unpackneg(q, pk); + scalarmult(p, q, d); + pack(shared, p); +}; + +export const crypto_verify_32 = (x, xi, y, yi) => { + return vn(x, xi, y, yi, 32); +}; + +export const add = (p, q) => { + // tslint:disable-next-line:one-variable-per-declaration + const a = gf(), + b = gf(), + c = gf(), + d = gf(), + e = gf(), + f = gf(), + g = gf(), + h = gf(), + t = gf(); + + Z(a, p[1], p[0]); + Z(t, q[1], q[0]); + M(a, a, t); + A(b, p[0], p[1]); + A(t, q[0], q[1]); + M(b, b, t); + M(c, p[3], q[3]); + M(c, c, D2); + M(d, p[2], q[2]); + A(d, d, d); + Z(e, b, a); + Z(f, d, c); + A(g, d, c); + A(h, b, a); + + M(p[0], e, f); + M(p[1], h, g); + M(p[2], g, f); + M(p[3], e, h); +}; + +export const modL = (r, x) => { + // tslint:disable-next-line:one-variable-per-declaration + let carry, i, j, k; + for (i = 63; i >= 32; --i) { + carry = 0; + for (j = i - 32, k = i - 12; j < k; ++j) { + x[j] += carry - 16 * x[i] * L[j - (i - 32)]; + carry = (x[j] + 128) >> 8; + x[j] -= carry * 256; + } + x[j] += carry; + x[i] = 0; + } + carry = 0; + for (j = 0; j < 32; j++) { + x[j] += carry - (x[31] >> 4) * L[j]; + carry = x[j] >> 8; + x[j] &= 255; + } + for (j = 0; j < 32; j++) { + x[j] -= carry * L[j]; + } + for (i = 0; i < 32; i++) { + x[i + 1] += x[i] >> 8; + r[i] = x[i] & 255; + } +}; + +export const reduce = (r) => { + // tslint:disable-next-line:one-variable-per-declaration + let x = new Float64Array(64), + i; + for (i = 0; i < 64; i++) { + x[i] = r[i]; + } + for (i = 0; i < 64; i++) { + r[i] = 0; + } + modL(r, x); +}; + +export const pack = (r, p) => { + // tslint:disable-next-line:one-variable-per-declaration + const tx = gf(), + ty = gf(), + zi = gf(); + inv25519(zi, p[2]); + M(tx, p[0], zi); + M(ty, p[1], zi); + pack25519(r, ty); + r[31] ^= par25519(tx) << 7; +}; + +export const scalarmult = (p, q, s) => { + // tslint:disable-next-line:one-variable-per-declaration + let b, i; + set25519(p[0], gf0); + set25519(p[1], gf1); + set25519(p[2], gf1); + set25519(p[3], gf0); + for (i = 255; i >= 0; --i) { + b = (s[(i / 8) | 0] >> (i & 7)) & 1; + cswap(p, q, b); + add(q, p); + add(p, p); + cswap(p, q, b); + } +}; + +export const scalarbase = (p, s) => { + const q = [gf(), gf(), gf(), gf()]; + set25519(q[0], X); + set25519(q[1], Y); + set25519(q[2], gf1); + M(q[3], X, Y); + scalarmult(p, q, s); +}; + +export const unpackneg = (r, p) => { + // tslint:disable-next-line:one-variable-per-declaration + const t = gf(), + chk = gf(), + num = gf(), + den = gf(), + den2 = gf(), + den4 = gf(), + den6 = gf(); + + set25519(r[2], gf1); + unpack25519(r[1], p); + S(num, r[1]); + M(den, num, D); + Z(num, num, r[2]); + A(den, r[2], den); + + S(den2, den); + S(den4, den2); + M(den6, den4, den2); + M(t, den6, num); + M(t, t, den); + + pow2523(t, t); + M(t, t, num); + M(t, t, den); + M(t, t, den); + M(r[0], t, den); + + S(chk, r[0]); + M(chk, chk, den); + if (neq25519(chk, num)) { + M(r[0], r[0], I); + } + + S(chk, r[0]); + M(chk, chk, den); + if (neq25519(chk, num)) { + return -1; + } + + if (par25519(r[0]) === (p[31] >> 7)) { + Z(r[0], gf0, r[0]); + } + + M(r[3], r[0], r[1]); + return 0; +}; diff --git a/src/model/account/Account.ts b/src/model/account/Account.ts index e94f7ec420..53acfdfc4e 100644 --- a/src/model/account/Account.ts +++ b/src/model/account/Account.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import {KeyPair, nacl_catapult} from 'nem2-library'; +import {Crypto, KeyPair} from '../../core/crypto'; import {Convert as convert, RawAddress as AddressLibrary} from '../../core/format'; import {NetworkType} from '../blockchain/NetworkType'; import {AggregateTransaction} from '../transaction/AggregateTransaction'; @@ -71,7 +71,7 @@ export class Account { public static generateNewAccount(networkType: NetworkType): Account { // Create random bytes - const randomBytesArray = nacl_catapult.randomBytes(32); + const randomBytesArray = Crypto.randomBytes(32); // Hash random bytes with entropy seed // Finalize and keep only 32 bytes const hashKey = convert.uint8ToHex(randomBytesArray); // TODO: derive private key correctly diff --git a/src/model/account/PublicAccount.ts b/src/model/account/PublicAccount.ts index 06b169e58e..84c2b2ea3c 100644 --- a/src/model/account/PublicAccount.ts +++ b/src/model/account/PublicAccount.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import { KeyPair } from 'nem2-library'; +import { KeyPair } from '../../core/crypto'; import { Convert as convert} from '../../core/format'; import { NetworkType } from '../blockchain/NetworkType'; import { Address } from './Address'; diff --git a/src/model/model.ts b/src/model/model.ts index c4d31efe5b..383305be0d 100644 --- a/src/model/model.ts +++ b/src/model/model.ts @@ -131,3 +131,4 @@ export * from './wallet/EncryptedPrivateKey'; export * from './wallet/Password'; export * from './wallet/SimpleWallet'; export * from './wallet/Wallet'; +export * from './wallet/WalletAlgorithm'; diff --git a/src/model/mosaic/MosaicNonce.ts b/src/model/mosaic/MosaicNonce.ts index 00985bd81a..2ef1dfe28f 100644 --- a/src/model/mosaic/MosaicNonce.ts +++ b/src/model/mosaic/MosaicNonce.ts @@ -13,9 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import { - nacl_catapult, -} from 'nem2-library'; +import {Crypto} from '../../core/crypto'; import { Convert as convert} from '../../core/format'; /** * The mosaic nonce structure @@ -35,7 +33,7 @@ export class MosaicNonce { * @return {MosaicNonce} */ public static createRandom(): MosaicNonce { - const bytes = nacl_catapult.randomBytes(4); + const bytes = Crypto.randomBytes(4); const nonce = new Uint8Array(bytes); return new MosaicNonce(nonce); } diff --git a/src/model/transaction/EncryptedMessage.ts b/src/model/transaction/EncryptedMessage.ts index 170378174b..de23a5516d 100644 --- a/src/model/transaction/EncryptedMessage.ts +++ b/src/model/transaction/EncryptedMessage.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import {crypto} from 'nem2-library'; +import {Crypto} from '../../core/crypto'; import {PublicAccount} from '../account/PublicAccount'; import {Message} from './Message'; import {MessageType} from './MessageType'; @@ -41,7 +41,7 @@ export class EncryptedMessage extends Message { */ public static create(message: string, recipientPublicAccount: PublicAccount, privateKey) { return new EncryptedMessage( - crypto.encode(privateKey, recipientPublicAccount.publicKey, message).toUpperCase(), + Crypto.encode(privateKey, recipientPublicAccount.publicKey, message).toUpperCase(), recipientPublicAccount); } @@ -60,6 +60,6 @@ export class EncryptedMessage extends Message { * @param recipientPublicAccount - Sender public account */ public static decrypt(encryptMessage: EncryptedMessage, privateKey, recipientPublicAccount: PublicAccount): PlainMessage { - return new PlainMessage(this.decodeHex(crypto.decode(privateKey, recipientPublicAccount.publicKey, encryptMessage.payload))); + return new PlainMessage(this.decodeHex(Crypto.decode(privateKey, recipientPublicAccount.publicKey, encryptMessage.payload))); } } diff --git a/src/model/wallet/EncryptedPrivateKey.ts b/src/model/wallet/EncryptedPrivateKey.ts index b6172679ee..ff6f21132b 100644 --- a/src/model/wallet/EncryptedPrivateKey.ts +++ b/src/model/wallet/EncryptedPrivateKey.ts @@ -14,8 +14,9 @@ * limitations under the License. */ -import {crypto} from 'nem2-library'; +import {Crypto} from '../../core/crypto'; import {Password} from './Password'; +import { WalletAlgorithm } from './WalletAlgorithm'; /** * EncryptedPrivateKey model @@ -52,7 +53,7 @@ export class EncryptedPrivateKey { encrypted: this.encryptedKey, iv: this.iv, }; - crypto.passwordToPrivatekey(common, wallet, 'pass:bip32'); + Crypto.passwordToPrivateKey(common, wallet, WalletAlgorithm.Pass_bip32); return common.privateKey; } } diff --git a/src/model/wallet/SimpleWallet.ts b/src/model/wallet/SimpleWallet.ts index 2797c6a3cb..f1ce97225d 100644 --- a/src/model/wallet/SimpleWallet.ts +++ b/src/model/wallet/SimpleWallet.ts @@ -15,7 +15,7 @@ */ import {LocalDateTime} from 'js-joda'; -import {crypto, KeyPair, nacl_catapult} from 'nem2-library'; +import {Crypto, KeyPair} from '../../core/crypto'; import { Convert as convert} from '../../core/format'; import {Account} from '../account/Account'; import {Address} from '../account/Address'; @@ -57,7 +57,7 @@ export class SimpleWallet extends Wallet { */ public static create(name: string, password: Password, network: NetworkType): SimpleWallet { // Create random bytes - const randomBytesArray = nacl_catapult.randomBytes(32); + const randomBytesArray = Crypto.randomBytes(32); // Hash random bytes with entropy seed // Finalize and keep only 32 bytes const hashKey = convert.uint8ToHex(randomBytesArray); // TODO: derive private key correctly @@ -69,7 +69,7 @@ export class SimpleWallet extends Wallet { const address = Address.createFromPublicKey(convert.uint8ToHex(keyPair.publicKey), network); // Encrypt private key using password - const encrypted = crypto.encodePrivKey(hashKey, password.value); + const encrypted = Crypto.encodePrivateKey(hashKey, password.value); const encryptedPrivateKey = new EncryptedPrivateKey(encrypted.ciphertext, encrypted.iv); @@ -92,7 +92,7 @@ export class SimpleWallet extends Wallet { const address = Address.createFromPublicKey(convert.uint8ToHex(keyPair.publicKey), network); // Encrypt private key using password - const encrypted = crypto.encodePrivKey(privateKey, password.value); + const encrypted = Crypto.encodePrivateKey(privateKey, password.value); const encryptedPrivateKey = new EncryptedPrivateKey(encrypted.ciphertext, encrypted.iv); diff --git a/src/model/wallet/WalletAlgorithm.ts b/src/model/wallet/WalletAlgorithm.ts new file mode 100644 index 0000000000..fd7bec5a2e --- /dev/null +++ b/src/model/wallet/WalletAlgorithm.ts @@ -0,0 +1,22 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export enum WalletAlgorithm { + Pass_6k = 1, + Pass_bip32 = 2, + Pass_enc = 4, + Trezor = 3, +} From f3840c9468b1170aa3a9ac5cc83680f761633455 Mon Sep 17 00:00:00 2001 From: Steven Liu Date: Wed, 12 Jun 2019 09:14:08 +0100 Subject: [PATCH 3/7] Added unit test --- test/core/crypto/crypto.spec.ts | 481 ++++++++++++++++++++++++++++ test/core/crypto/keyPair.spec.ts | 420 ++++++++++++++++++++++++ test/core/crypto/sha3Hasher.spec.ts | 150 +++++++++ 3 files changed, 1051 insertions(+) create mode 100644 test/core/crypto/crypto.spec.ts create mode 100644 test/core/crypto/keyPair.spec.ts create mode 100644 test/core/crypto/sha3Hasher.spec.ts diff --git a/test/core/crypto/crypto.spec.ts b/test/core/crypto/crypto.spec.ts new file mode 100644 index 0000000000..f022085c48 --- /dev/null +++ b/test/core/crypto/crypto.spec.ts @@ -0,0 +1,481 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {Crypto} from '../../../src/core/crypto'; +import {Convert as convert} from '../../../src/core/format'; +import { WalletAlgorithm } from '../../../src/model/model'; + +const CryptoJS = require('crypto-js'); +describe('crypto tests', () => { + it('Can derive a key from password and count', () => { + // Arrange: + const password = 'TestTest'; + const count = 20; + const expectedKey = '8cd87bc513857a7079d182a6e19b370e907107d97bd3f81a85bcebcc4b5bd3b5'; + + // Act: + const result = Crypto.derivePassSha(password, count); + + // Assert: + expect(result.priv).equal(expectedKey); + }); + + it('Can encrypt a private key', () => { + // Arrange: + const password = 'TestTest'; + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const expectedKey = '8cd87bc513857a7079d182a6e19b370e907107d97bd3f81a85bcebcc4b5bd3b5'; + + // Act: + const result = Crypto.encodePrivateKey(privateKey, password); + const pass = Crypto.derivePassSha(password, 20); + + // Assert: + expect(pass.priv).equal(expectedKey); + expect(result.iv.length).equal(16 * 2); + expect(result.ciphertext.length).equal(48 * 2); + }); + + it('Can decrypt a private key', () => { + // Arrange: + const expectedPrivateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const key = '8cd87bc513857a7079d182a6e19b370e907107d97bd3f81a85bcebcc4b5bd3b5'; + const encrypted = 'c09ef3ed0cadd6ca6d3638b5dd854ac871a0afaec6b7fed791166b571a64d57f564376dc0180c851b0a1120b5896e6a0'; + const iv = '0329814121c7a4bb11418084dbe40560'; + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(encrypted), + iv: convert.hexToUint8(iv), + key: convert.hexToUint8(key), + }; + + // Act: + const decrypted = Crypto.decrypt(obj); + + // Assert: + expect(decrypted).equal(expectedPrivateKey); + }); + + it('Can encrypt and decrypt private Key', () => { + // Arrange: + const password = 'TestTest'; + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.encodePrivateKey(privateKey, password); + const pass = Crypto.derivePassSha(password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(result.ciphertext), + iv: convert.hexToUint8(result.iv), + key: convert.hexToUint8(pass.priv), + }; + const decrypted = Crypto.decrypt(obj); + + // Assert: + expect(privateKey).equal(decrypted); + }); + + describe('Encrypt private key edge-cases', () => { + it('Encryption throw error if no password', () => { + // Arrange: + const password = ''; + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.encodePrivateKey.bind(null, privateKey, password); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Encryption throw error if no private key', () => { + // Arrange: + const password = 'TestTest'; + const privateKey = ''; + + // Act + const result = Crypto.encodePrivateKey.bind(null, privateKey, password); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + }); + + it('Can decrypt private key of pass:enc wallets', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_enc; + const expectedPrivateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Can decrypt private key of pass:bip32 wallets', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_bip32; + const expectedPrivateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Can decrypt private key of pass:6k wallets', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '', + iv: '', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + const expectedPrivateKey = '8fac70ea9aca3ae3418e25c0d31d9a0723e0a1790ae8fa97747c00dc0037472e'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Can decrypt private key of pass:6k wallets childs', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '5c3a7ebbefb391e5175a29ec5a22cb162cd590bb2e0b09416273f86bdc39fa83c04c4bb53b9c64fd1e6eaba5dba149bd', + iv: 'f131d9a4dfb1b0b696e05ccae9412e8f', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + const expectedPrivateKey = '4f27ca43521bbc394a6f6dde65b533e0768f954fa47ce320b0e9f4b5fe450f9d'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + describe('Decrypt private key edge-cases', () => { + it('Private key decryption throw error if no algo', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = ''; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:enc wallets thow error if no password', () => { + // Arrange: + const common = { + password: '', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_enc; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:bip32 wallets throw error if no password', () => { + // Arrange: + const common = { + password: '', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_bip32; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:6k wallets throw error if no password', () => { + // Arrange: + const common = { + password: '', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:6k wallets generate a private key if no encrypted and iv in wallet account', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '', + iv: '', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + const expectedPrivateKey = '8fac70ea9aca3ae3418e25c0d31d9a0723e0a1790ae8fa97747c00dc0037472e'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Decryption of pass:6k wallets return false if encrypted data but no iv', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: '', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(false); + expect(common.privateKey).equal(''); + }); + + it('Decryption of pass:6k wallets return false if no encrypted data but iv', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(false); + expect(common.privateKey).equal(''); + }); + }); + + it('Can encode and decode message', () => { + const senderPriv = 'E1C8521608F4896CA26A0C2DE739310EA4B06861D126CF4D6922064678A1969B'; + const recipientPublic = '12AAD2D33020C3EAE12592875CD7D2FF54A61DD03C1FAADB84A083D41F75C229'; + const message = 'NEM is awesome !'; + const encryptedMessage = Crypto.encode(senderPriv, recipientPublic, message); + const senderPublic = '9F784BF20318AE3CA6246C0EC2207FE095FFF7A84B6787E7E3C2CE4C3B92A2EA'; + const recipientPriv = 'A22A4BBF126A2D7D7ECE823174DFD184C5DE0FDE4CB2075D30CFA409F7EF8908'; + const expectedMessage = 'NEM is awesome !'; + const decrypted = Crypto.decode(recipientPriv, senderPublic, encryptedMessage); + + expect(decrypted).equal(convert.utf8ToHex(expectedMessage)); + }); + + it('Can encode a message and failed decode with wrong key', () => { + const senderPriv = 'E1C8521608F4896CA26A0C2DE739310EA4B06861D126CF4D6922064678A1969B'; + const recipientPublic = '12AAD2D33020C3EAE12592875CD7D2FF54A61DD03C1FAADB84A083D41F75C229'; + const message = 'NEM is awesome !'; + const encryptedMessage = Crypto.encode(senderPriv, recipientPublic, message); + const senderPublic = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6'; + const recipientPriv = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6'; + const expectedMessage = 'NEM is awesome !'; + const decrypted = Crypto.decode(recipientPriv, senderPublic, encryptedMessage); + + expect(decrypted).not.equal(convert.utf8ToHex(expectedMessage)); + }); + + describe('Encode & decode message edge-cases', () => { + it('Message encoding throw error if no sender private key', () => { + // Arrange: + const senderPriv = ''; + const recipientPublic = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = 'NEM is awesome !'; + + // Act: + const result = Crypto.encode.bind(null, senderPriv, recipientPublic, message); + + // Assert: + expect(result).to.throw(); + }); + + it('Message encoding throw error if no recipient public key', () => { + // Arrange: + const senderPriv = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const recipientPublic = ''; + const message = 'NEM is awesome !'; + + // Act: + const result = Crypto.encode.bind(null, senderPriv, recipientPublic, message); + + // Assert: + expect(result).to.throw(); + }); + + it('Message encoding throw error if no message', () => { + // Arrange: + const senderPriv = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const recipientPublic = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = ''; + + // Act: + const result = Crypto.encode.bind(null, senderPriv, recipientPublic, message); + + // Assert: + expect(result).to.throw(); + }); + + it('Message decoding throw error if no recipient private key', () => { + // Arrange: + const senderPublic = '9291abb3c52134be9d20ef21a796743497df7776d2661237bda9cadade34e44c'; + const recipientPriv = ''; + const message = 'NEM is awesome !'; + const encryptedMessage = 'dd31d6b4111c1023bae6533399e74f73a29c6e6b48ab550f8a7bea127e27ddd' + + 'b4fd3fe4fad3c835307c0da52d9c268f56237d1810e07912e6a6568cba09d9a9176ee6b1ade9569c2e1e273e9675bd4ff'; + + // Act: + const result = Crypto.decode.bind(null, recipientPriv, senderPublic, encryptedMessage); + + // Assert: + expect(result).to.throw(); + }); + + it('Message decoding throw error if no sender public key', () => { + // Arrange: + const senderPublic = ''; + const recipientPriv = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = 'NEM is awesome !'; + const encryptedMessage = 'dd31d6b4111c1023bae6533399e74f73a29c6e6b48ab550f8a7bea127e27ddd' + + 'b4fd3fe4fad3c835307c0da52d9c268f56237d1810e07912e6a6568cba09d9a9176ee6b1ade9569c2e1e273e9675bd4ff'; + + // Act: + const result = Crypto.decode.bind(null, recipientPriv, senderPublic, encryptedMessage); + + // Assert: + expect(result).to.throw(); + }); + + it('Message decoding throw error if no payload', () => { + // Arrange: + const senderPublic = '9291abb3c52134be9d20ef21a796743497df7776d2661237bda9cadade34e44c'; + const recipientPriv = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = 'NEM is awesome !'; + const encryptedMessage = ''; + + // Act: + const result = Crypto.decode.bind(null, recipientPriv, senderPublic, encryptedMessage); + + // Assert: + expect(result).to.throw(); + }); + }); + + it('Can encrypt and decrypt private key for mobile', () => { + // Arrange: + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const password = 'TestTest'; + + // Act: + const result = Crypto.toMobileKey(password, privateKey); + const encrypted = result.encrypted; + const salt = CryptoJS.enc.Hex.parse(result.salt); + + const key = CryptoJS.PBKDF2(password, salt, { + keySize: 256 / 32, + iterations: 2000, + }); + + const iv = encrypted.substring(0, 32); + const encryptedPrvKey = encrypted.substring(32, 128); + + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(encryptedPrvKey), + iv: convert.hexToUint8(iv), + key: convert.hexToUint8(key.toString()), + }; + + const decrypted = Crypto.decrypt(obj); + + // Assert: + expect(encrypted.length).equal(128); + expect(salt.toString().length).equal(32 * 2); + expect(decrypted).equal(privateKey); + }); +}); diff --git a/test/core/crypto/keyPair.spec.ts b/test/core/crypto/keyPair.spec.ts new file mode 100644 index 0000000000..8f4d9af157 --- /dev/null +++ b/test/core/crypto/keyPair.spec.ts @@ -0,0 +1,420 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {Crypto, KeyPair} from '../../../src/core/crypto'; +import {Convert as convert} from '../../../src/core/format'; + +describe('key pair', () => { + const randomKeyPair = () => KeyPair.createKeyPairFromPrivateKeyString(convert.uint8ToHex(Crypto.randomBytes(32))); + const Private_Key_Size = 32; + const Signature_Size = 64; + + const Private_Keys = [ + '8D31B712AB28D49591EAF5066E9E967B44507FC19C3D54D742F7B3A255CFF4AB', + '15923F9D2FFFB11D771818E1F7D7DDCD363913933264D58533CB3A5DD2DAA66A', + 'A9323CEF24497AB770516EA572A0A2645EE2D5A75BC72E78DE534C0A03BC328E', + 'D7D816DA0566878EE739EDE2131CD64201BCCC27F88FA51BA5815BCB0FE33CC8', + '27FC9998454848B987FAD89296558A34DEED4358D1517B953572F3E0AAA0A22D', + ]; + + describe('construction', () => { + it('can extract from private key test vectors', () => { + // Arrange: + const Expected_Public_Keys = [ + '53C659B47C176A70EB228DE5C0A0FF391282C96640C2A42CD5BBD0982176AB1B', + '3FE4A1AA148F5E76891CE924F5DC05627A87047B2B4AD9242C09C0ECED9B2338', + 'F398C0A2BDACDBD7037D2F686727201641BBF87EF458F632AE2A04B4E8F57994', + '6A283A241A8D8203B3A1E918B1E6F0A3E14E75E16D4CFFA45AE4EF89E38ED6B5', + '4DC62B38215826438DE2369743C6BBE6D13428405025DFEFF2857B9A9BC9D821', + ]; + + // Sanity: + expect(Private_Keys.length).equal(Expected_Public_Keys.length); + + for (let i = 0; i < Private_Keys.length; ++i) { + // Arrange: + const privateKeyHex = Private_Keys[i]; + const expectedPublicKey = Expected_Public_Keys[i]; + + // Act: + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(privateKeyHex); + + // Assert: + const message = ` from ${privateKeyHex}`; + expect(convert.uint8ToHex(keyPair.publicKey), `public ${message}`).equal(expectedPublicKey); + expect(convert.uint8ToHex(keyPair.privateKey), `private ${message}`).equal(privateKeyHex); + } + }); + + it('cannot extract from invalid private key', () => { + // Arrange: + const invalidPrivateKeys = [ + '', // empty + '53C659B47C176A70EB228DE5C0A0FF391282C96640C2A42CD5BBD0982176AB', // short + '53C659B47C176A70EB228DE5C0A0FF391282C96640C2A42CD5BBD0982176AB1BBB', // long + ]; + + // Act: + invalidPrivateKeys.forEach((privateKey) => { + // Assert: + expect(() => { + KeyPair.createKeyPairFromPrivateKeyString(privateKey); + }, `from ${privateKey}`) + .to.throw('private key has unexpected size'); + }); + }); + }); + + describe('sign', () => { + it('fills the signature', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + + // Act: + const signature = KeyPair.sign(keyPair, payload); + + // Assert: + expect(signature).to.not.deep.equal(new Uint8Array(Signature_Size)); + }); + + it('returns same signature for same data signed by same key pairs', () => { + // Arrange: + const privateKey = convert.uint8ToHex(Crypto.randomBytes(Private_Key_Size)); + const keyPair1 = KeyPair.createKeyPairFromPrivateKeyString(privateKey); + const keyPair2 = KeyPair.createKeyPairFromPrivateKeyString(privateKey); + const payload = Crypto.randomBytes(100); + + // Act: + const signature1 = KeyPair.sign(keyPair1, payload); + const signature2 = KeyPair.sign(keyPair2, payload); + + // Assert: + expect(signature2).to.deep.equal(signature1); + }); + + it('returns different signature for same data signed by different key pairs', () => { + // Arrange: + const keyPair1 = randomKeyPair(); + const keyPair2 = randomKeyPair(); + const payload = Crypto.randomBytes(100); + + // Act: + const signature1 = KeyPair.sign(keyPair1, payload); + const signature2 = KeyPair.sign(keyPair2, payload); + + // Assert: + expect(signature2).to.not.deep.equal(signature1); + }); + + it('cannot sign unsupported data type', () => { + // Arrange: + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(Private_Keys[0]); + + // Assert: + expect(() => { + KeyPair.sign(keyPair, {}); + }).to.throw('unsupported data type'); + }); + }); + + describe('verify', () => { + it('returns true for data signed with same key pair', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(true); + }); + + it('returns false for data signed with different key pair', () => { + // Arrange: + const keyPair1 = randomKeyPair(); + const keyPair2 = randomKeyPair(); + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair1, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair2.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('returns false if signature has been modified', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + + for (let i = 0; i < Signature_Size; i += 4) { + const signature = KeyPair.sign(keyPair, payload); + signature[i] ^= 0xFF; + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified, `signature modified at ${i}`).to.equal(false); + } + }); + + it('returns false if payload has been modified', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(44); + + for (let i = 0; i < payload.length; i += 4) { + const signature = KeyPair.sign(keyPair, payload); + payload[i] ^= 0xFF; + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified, `payload modified at ${i}`).to.equal(false); + } + }); + + it('fails if public key is not on curve', () => { + // Arrange: + const keyPair = randomKeyPair(); + keyPair.publicKey.fill(0); + keyPair.publicKey[keyPair.publicKey.length - 1] = 1; + + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('fails if public key does not correspond to private key', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + for (let i = 0; i < keyPair.publicKey.length; ++i) { + keyPair.publicKey[i] ^= 0xFF; + } + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('rejects zero public key', () => { + // Arrange: + const keyPair = randomKeyPair(); + keyPair.publicKey.fill(0); + + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('cannot verify non canonical signature', () => { + function scalarAddGroupOrder(scalar) { + // 2^252 + 27742317777372353535851937790883648493, little endian + const Group_Order = [ + 0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + ]; + + let r = 0; + for (let i = 0; i < scalar.length; ++i) { + const t = scalar[i] + Group_Order[i]; + scalar[i] += Group_Order[i] + r; + r = (t >> 8) & 0xFF; + } + } + + // Arrange: + const keyPair = randomKeyPair(); + const payload = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]); + const canonicalSignature = KeyPair.sign(keyPair, payload); + + // this is signature with group order added to 'encodedS' part of signature + const nonCanonicalSignature = canonicalSignature.slice(); + scalarAddGroupOrder(nonCanonicalSignature.subarray(32)); + + // Act: + const isCanonicalVerified = KeyPair.verify(keyPair.publicKey, payload, canonicalSignature); + const isNonCanonicalVerified = KeyPair.verify(keyPair.privateKey, payload, nonCanonicalSignature); + + // Assert: + expect(isCanonicalVerified).to.equal(true); + expect(isNonCanonicalVerified).to.equal(false); + }); + }); + + describe('test vectors', () => { + const Input_Data = [ + '8ce03cd60514233b86789729102ea09e867fc6d964dea8c2018ef7d0a2e0e24bf7e348e917116690b9', + 'e4a92208a6fc52282b620699191ee6fb9cf04daf48b48fd542c5e43daa9897763a199aaa4b6f10546109f47ac3564fade0', + '13ed795344c4448a3b256f23665336645a853c5c44dbff6db1b9224b5303b6447fbf8240a2249c55', + 'a2704638434e9f7340f22d08019c4c8e3dbee0df8dd4454a1d70844de11694f4c8ca67fdcb08fed0cec9abb2112b5e5f89', + 'd2488e854dbcdfdb2c9d16c8c0b2fdbc0abb6bac991bfe2b14d359a6bc99d66c00fd60d731ae06d0', + ]; + const Expected_Signatures = [ + 'C9B1342EAB27E906567586803DA265CC15CCACA411E0AEF44508595ACBC47600D0' + + '2527F2EED9AB3F28C856D27E30C3808AF7F22F5F243DE698182D373A9ADE03', + '0755E437ED4C8DD66F1EC29F581F6906AB1E98704ECA94B428A25937DF00EC6479' + + '6F08E5FEF30C6F6C57E4A5FB4C811D617FA661EB6958D55DAE66DDED205501', + '15D6585A2A456E90E89E8774E9D12FE01A6ACFE09936EE41271AA1FBE0551264A9' + + 'FF9329CB6FEE6AE034238C8A91522A6258361D48C5E70A41C1F1C51F55330D', + 'F6FB0D8448FEC0605CF74CFFCC7B7AE8D31D403BCA26F7BD21CB4AC87B00769E9C' + + 'C7465A601ED28CDF08920C73C583E69D621BA2E45266B86B5FCF8165CBE309', + 'E88D8C32FE165D34B775F70657B96D8229FFA9C783E61198A6F3CCB92F487982D0' + + '8F8B16AB9157E2EFC3B78F126088F585E26055741A9F25127AC13E883C9A05', + ]; + + function assertCanSignTestVectors(dataTransform) { + // Sanity: + expect(Private_Keys.length).equal(Input_Data.length); + expect(Private_Keys.length).equal(Expected_Signatures.length); + + for (let i = 0; i < Private_Keys.length; ++i) { + // Arrange: + const inputData = dataTransform(Input_Data[i]); + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(Private_Keys[i]); + + // Act: + const signature = KeyPair.sign(keyPair, inputData); + + // Assert: + const message = `signing with ${Private_Keys[i]}`; + expect(convert.uint8ToHex(signature), message).equal(Expected_Signatures[i]); + } + } + + it('can sign test vectors as hex string', () => { + // Assert: + assertCanSignTestVectors((data) => data); + }); + + it('can sign test vectors as binary', () => { + // Assert: + assertCanSignTestVectors((data) => convert.hexToUint8(data)); + }); + + function assertCanVerifyTestVectors(dataTransform) { + // Sanity: + expect(Private_Keys.length).equal(Input_Data.length); + expect(Private_Keys.length).equal(Expected_Signatures.length); + + for (let i = 0; i < Private_Keys.length; ++i) { + // Arrange: + const inputData = dataTransform(Input_Data[i]); + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(Private_Keys[i]); + const signature = KeyPair.sign(keyPair, inputData); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, inputData, signature); + + // Assert: + const message = `verifying with ${Private_Keys[i]}`; + expect(isVerified, message).equal(true); + } + } + + it('can verify test vectors as hex string', () => { + // Assert: + assertCanVerifyTestVectors((data) => data); + }); + + it('can verify test vectors as binary', () => { + // Assert: + assertCanVerifyTestVectors((data) => convert.hexToUint8(data)); + }); + }); + + describe('derive shared key', () => { + const Salt_Size = 32; + + it('fails if salt is wrong size', () => { + // Arrange: create a salt that is too long + const keyPair = randomKeyPair(); + const publicKey = Crypto.randomBytes(32); + const salt = Crypto.randomBytes(Salt_Size + 1); + + // Act: + expect(() => { + KeyPair.deriveSharedKey(keyPair, publicKey, salt); + }) + .to.throw('salt has unexpected size'); + }); + + it('derives same shared key for both partners', () => { + // Arrange: + const keyPair1 = randomKeyPair(); + const keyPair2 = randomKeyPair(); + const salt = Crypto.randomBytes(Salt_Size); + + // Act: + const sharedKey1 = KeyPair.deriveSharedKey(keyPair1, keyPair2.publicKey, salt); + const sharedKey2 = KeyPair.deriveSharedKey(keyPair2, keyPair1.publicKey, salt); + + // Assert: + expect(sharedKey1).to.deep.equal(sharedKey2); + }); + + it('derives different shared keys for different partners', () => { + // Arrange: + const keyPair = randomKeyPair(); + const publicKey1 = Crypto.randomBytes(32); + const publicKey2 = Crypto.randomBytes(32); + const salt = Crypto.randomBytes(Salt_Size); + + // Act: + const sharedKey1 = KeyPair.deriveSharedKey(keyPair, publicKey1, salt); + const sharedKey2 = KeyPair.deriveSharedKey(keyPair, publicKey2, salt); + + // Assert: + expect(sharedKey1).to.not.deep.equal(sharedKey2); + }); + + it('can derive deterministic shared key from well known inputs', () => { + // Arrange: + const privateKey = convert.hexToUint8('8F545C2816788AB41D352F236D80DBBCBC34705B5F902EFF1F1D88327C7C1300'); + const publicKey = convert.hexToUint8('BF684FB1A85A8C8091EE0442EDDB22E51683802AFA0C0E7C6FE3F3E3E87A8D72'); + const salt = convert.hexToUint8('422C39DF16AAE42A74A5597D6EE2D59CFB4EEB6B3F26D98425B9163A03DAA3B5'); + + // Act: + const sharedKey = KeyPair.deriveSharedKey({ + privateKey, + }, publicKey, salt); + + // Assert: + expect(convert.uint8ToHex(sharedKey)).to.equal('FF9623D28FBC13B6F0E0659117FC7BE294DB3385C046055A6BAC39EDF198D50D'); + }); + }); +}); diff --git a/test/core/crypto/sha3Hasher.spec.ts b/test/core/crypto/sha3Hasher.spec.ts new file mode 100644 index 0000000000..4f9b731238 --- /dev/null +++ b/test/core/crypto/sha3Hasher.spec.ts @@ -0,0 +1,150 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {SHA3Hasher as sha3Hasher} from '../../../src/core/crypto/SHA3Hasher'; +import {Convert as convert} from '../../../src/core/format'; + +describe('hasher', () => { + const inputs = [ + '', + 'CC', + '41FB', + '1F877C', + 'C1ECFDFC', + '9F2FCC7C90DE090D6B87CD7E9718C1EA6CB21118FC2D5DE9F97E5DB6AC1E9C10' + ]; + + function addSha3Tests(length, expectedOutputs) { + describe('func', () => { + it('can hash test vectors', () => { + // Sanity: + expect(expectedOutputs.length).equal(inputs.length); + + for (let i = 0; i < inputs.length; ++i) { + // Arrange: + const inputHex = inputs[i]; + const inputBuffer = convert.hexToUint8(inputHex); + const expectedHash = expectedOutputs[i]; + + // Act: + const hash = new Uint8Array(length); + sha3Hasher.func(hash, inputBuffer, length); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + } + }); + }); + + describe('object', () => { + it('can hash test vectors', () => { + // Sanity: + expect(expectedOutputs.length).equal(inputs.length); + + for (let i = 0; i < inputs.length; ++i) { + // Arrange: + const inputHex = inputs[i]; + const inputBuffer = convert.hexToUint8(inputHex); + const expectedHash = expectedOutputs[i]; + + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + + // Act: hash the input in two parts + hasher.update(inputBuffer.subarray(0, inputBuffer.length / 2)); + hasher.update(inputBuffer.subarray(inputBuffer.length / 2)); + + const hash = new Uint8Array(length); + hasher.finalize(hash); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + } + }); + + it('can hash string', () => { + // Arrange: + const inputHex = inputs[3]; + const expectedHash = expectedOutputs[3]; + + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + + // Act: + hasher.update(inputHex); + + const hash = new Uint8Array(length); + hasher.finalize(hash); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + }); + + it('cannot hash unsupported data type', () => { + // Arrange: + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + + // Act: + expect(() => hasher.update({})).to.throw('unsupported data type'); + }); + + it('can reuse after reset', () => { + // Arrange: + const inputHex = inputs[3]; + const expectedHash = expectedOutputs[3]; + + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + hasher.update('ABCD'); + + // Act: + hasher.reset(); + hasher.update(inputHex); + + const hash = new Uint8Array(length); + hasher.finalize(hash); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + }); + }); + } + + describe('sha3 256', () => { + // https://github.com/gvanas/KeccakCodePackage/blob/master/TestVectors/ShortMsgKAT_SHA3-256.txt + addSha3Tests(32, [ + 'A7FFC6F8BF1ED76651C14756A061D662F580FF4DE43B49FA82D80A4B80F8434A', + '677035391CD3701293D385F037BA32796252BB7CE180B00B582DD9B20AAAD7F0', + '39F31B6E653DFCD9CAED2602FD87F61B6254F581312FB6EEEC4D7148FA2E72AA', + 'BC22345E4BD3F792A341CF18AC0789F1C9C966712A501B19D1B6632CCD408EC5', + 'C5859BE82560CC8789133F7C834A6EE628E351E504E601E8059A0667FF62C124', + '2F1A5F7159E34EA19CDDC70EBF9B81F1A66DB40615D7EAD3CC1F1B954D82A3AF' + ]); + }); + + describe('sha3 512', () => { + // https://github.com/gvanas/KeccakCodePackage/blob/master/TestVectors/ShortMsgKAT_SHA3-512.txt + addSha3Tests(64, [ + 'A69F73CCA23A9AC5C8B567DC185A756E97C982164FE25859E0D1DCC1475C80A615B2123AF1F5F94C11E3E9402C3AC558F500199D95B6D3E301758586281DCD26', + '3939FCC8B57B63612542DA31A834E5DCC36E2EE0F652AC72E02624FA2E5ADEECC7DD6BB3580224B4D6138706FC6E80597B528051230B00621CC2B22999EAA205', + 'AA092865A40694D91754DBC767B5202C546E226877147A95CB8B4C8F8709FE8CD6905256B089DA37896EA5CA19D2CD9AB94C7192FC39F7CD4D598975A3013C69', + 'CB20DCF54955F8091111688BECCEF48C1A2F0D0608C3A575163751F002DB30F40F2F671834B22D208591CFAF1F5ECFE43C49863A53B3225BDFD7C6591BA7658B', + 'D4B4BDFEF56B821D36F4F70AB0D231B8D0C9134638FD54C46309D14FADA92A2840186EED5415AD7CF3969BDFBF2DAF8CCA76ABFE549BE6578C6F4143617A4F1A', + 'B087C90421AEBF87911647DE9D465CBDA166B672EC47CCD4054A7135A1EF885E7903B52C3F2C3FE722B1C169297A91B82428956A02C631A2240F12162C7BC726' + ]); + }); +}); From f82c31267ee236491df3ca3a63c251c5970d79ba Mon Sep 17 00:00:00 2001 From: Steven Liu Date: Wed, 12 Jun 2019 09:36:37 +0100 Subject: [PATCH 4/7] Added #170 Merged existing buffers and schemas --- .../buffers/AccountLinkTransactionBuffer.ts | 425 ++++++++++ ...countPropertiesAddressTransactionBuffer.ts | 557 +++++++++++++ ...ntPropertiesEntityTypeTransactionBuffer.ts | 520 ++++++++++++ ...ccountPropertiesMosaicTransactionBuffer.ts | 557 +++++++++++++ .../buffers/AddressAliasTransactionBuffer.ts | 479 +++++++++++ .../buffers/AggregateTransactionBuffer.ts | 425 ++++++++++ .../buffers/HashLockTransactionBuffer.ts | 571 +++++++++++++ .../buffers/MosaicAliasTransactionBuffer.ts | 479 +++++++++++ .../MosaicCreationTransactionBuffer.ts | 582 +++++++++++++ .../MosaicSupplyChangeTransactionBuffer.ts | 479 +++++++++++ .../MultisigModificationTransactionBuffer.ts | 571 +++++++++++++ .../NamespaceCreationTransactionBuffer.ts | 512 ++++++++++++ .../buffers/SecretLockTransactionBuffer.ts | 641 ++++++++++++++ .../buffers/SecretProofTransactionBuffer.ts | 549 ++++++++++++ .../buffers/TransferTransactionBuffer.ts | 785 ++++++++++++++++++ .../schemas/AccountLinkTransactionSchema.ts | 44 + ...iesAddressModificationTransactionSchema.ts | 48 ++ ...EntityTypeModificationTransactionSchema.ts | 48 ++ ...tiesMosaicModificationTransactionSchema.ts | 48 ++ .../schemas/AddressAliasTransactionSchema.ts | 44 + .../schemas/AggregateTransactionSchema.ts | 44 + .../schemas/HashLockTransactionSchema.ts | 45 + .../schemas/MosaicAliasTransactionSchema.ts | 44 + .../MosaicCreationTransactionSchema.ts | 63 ++ .../MosaicSupplyChangeTransactionSchema.ts | 44 + .../MultisigModificationTransactionSchema.ts | 49 ++ .../NamespaceCreationTransactionSchema.ts | 47 ++ src/infrastructure/schemas/Schema.ts | 374 +++++++++ .../schemas/SecretLockTransactionSchema.ts | 48 ++ .../schemas/SecretProofTransactionSchema.ts | 47 ++ .../schemas/TransferTransactionSchema.ts | 55 ++ 31 files changed, 9224 insertions(+) create mode 100644 src/infrastructure/buffers/AccountLinkTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AddressAliasTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AggregateTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/HashLockTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/SecretLockTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/SecretProofTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/TransferTransactionBuffer.ts create mode 100644 src/infrastructure/schemas/AccountLinkTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AddressAliasTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AggregateTransactionSchema.ts create mode 100644 src/infrastructure/schemas/HashLockTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MosaicAliasTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MosaicCreationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MultisigModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/Schema.ts create mode 100644 src/infrastructure/schemas/SecretLockTransactionSchema.ts create mode 100644 src/infrastructure/schemas/SecretProofTransactionSchema.ts create mode 100644 src/infrastructure/schemas/TransferTransactionSchema.ts diff --git a/src/infrastructure/buffers/AccountLinkTransactionBuffer.ts b/src/infrastructure/buffers/AccountLinkTransactionBuffer.ts new file mode 100644 index 0000000000..30dde827ce --- /dev/null +++ b/src/infrastructure/buffers/AccountLinkTransactionBuffer.ts @@ -0,0 +1,425 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.AccountLinkTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountLinkTransactionBuffer} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountLinkTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountLinkTransactionBuffer} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.getRootAsAccountLinkTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountLinkTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signerLength = function() { + let offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signerArray = function() { + let offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.version = function() { + let offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.type = function() { + let offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.fee = function(index) { + const offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.feeLength = function() { + const offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.feeArray = function() { + const offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.deadline = function(index) { + const offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.deadlineLength = function() { + const offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.deadlineArray = function() { + const offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.remoteAccountKey = function(index) { + const offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.remoteAccountKeyLength = function() { + const offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.remoteAccountKeyArray = function() { + const offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.linkAction = function() { + const offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startAccountLinkTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} remoteAccountKey + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addRemoteAccountKey = function(builder, remoteAccountKeyOffset) { + builder.addFieldOffset(7, remoteAccountKeyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createRemoteAccountKeyVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startRemoteAccountKeyVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} linkAction + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addLinkAction = function(builder, linkAction) { + builder.addFieldInt8(8, linkAction, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.endAccountLinkTransactionBuffer = function(builder) { + const offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.finishAccountLinkTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts b/src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts new file mode 100644 index 0000000000..128442e660 --- /dev/null +++ b/src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts @@ -0,0 +1,557 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.PropertyAddressModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.PropertyAddressModificationBuffer} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.PropertyAddressModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyAddressModificationBuffer} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.getRootAsPropertyAddressModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.PropertyAddressModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.modificationType = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.value = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.valueLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.valueArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.PropertyAddressModificationBuffer.startPropertyAddressModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.PropertyAddressModificationBuffer.addModificationType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} valueOffset + */ +Catapult.Buffers.PropertyAddressModificationBuffer.addValue = function(builder, valueOffset) { + builder.addFieldOffset(1, valueOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.createValueVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.PropertyAddressModificationBuffer.startValueVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.endPropertyAddressModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountPropertiesAddressTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountPropertiesAddressTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountPropertiesAddressTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.getRootAsAccountPropertiesAddressTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountPropertiesAddressTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.propertyType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.modificationCount = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.PropertyAddressModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyAddressModificationBuffer} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new Catapult.Buffers.PropertyAddressModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startAccountPropertiesAddressTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} propertyType + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addPropertyType = function(builder, propertyType) { + builder.addFieldInt8(7, propertyType, 0); +}; + + +/** + * @param {flatbuffers.Builder} builder + * @param {number} modificationCount + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addModificationCount = function(builder, modificationCount) { + builder.addFieldInt8(8, modificationCount, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(9, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.endAccountPropertiesAddressTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.finishAccountPropertiesAddressTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts b/src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts new file mode 100644 index 0000000000..0994479bf7 --- /dev/null +++ b/src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts @@ -0,0 +1,520 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.PropertyEntityTypeModificationBuffer} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.PropertyEntityTypeModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyEntityTypeModificationBuffer} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.getRootAsPropertyEntityTypeModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.PropertyEntityTypeModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.prototype.modificationType = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.prototype.value = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.startPropertyEntityTypeModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.addModificationType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} valueOffset + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.addValue = function(builder, valueOffset) { + builder.addFieldInt16(1, valueOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.endPropertyEntityTypeModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.getRootAsAccountPropertiesEntityTypeTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.propertyType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.modificationCount = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.PropertyEntityTypeModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyEntityTypeModificationBuffer} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new Catapult.Buffers.PropertyEntityTypeModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startAccountPropertiesEntityTypeTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} propertyType + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addPropertyType = function(builder, propertyType) { + builder.addFieldInt8(7, propertyType, 0); +}; + + +/** + * @param {flatbuffers.Builder} builder + * @param {number} modificationCount + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addModificationCount = function(builder, modificationCount) { + builder.addFieldInt8(8, modificationCount, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(9, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.endAccountPropertiesEntityTypeTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.finishAccountPropertiesEntityTypeTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts b/src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts new file mode 100644 index 0000000000..59241cc50e --- /dev/null +++ b/src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts @@ -0,0 +1,557 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.PropertyMosaicModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.PropertyMosaicModificationBuffer} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.PropertyMosaicModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyMosaicModificationBuffer} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.getRootAsPropertyMosaicModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.PropertyMosaicModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.modificationType = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.value = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.valueLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.valueArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.startPropertyMosaicModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.addModificationType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} valueOffset + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.addValue = function(builder, valueOffset) { + builder.addFieldOffset(1, valueOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.createValueVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.startValueVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.endPropertyMosaicModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.getRootAsAccountPropertiesMosaicTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.propertyType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.modificationCount = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.PropertyMosaicModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyMosaicModificationBuffer} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new Catapult.Buffers.PropertyMosaicModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startAccountPropertiesMosaicTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} propertyType + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addPropertyType = function(builder, propertyType) { + builder.addFieldInt8(7, propertyType, 0); +}; + + +/** + * @param {flatbuffers.Builder} builder + * @param {number} modificationCount + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addModificationCount = function(builder, modificationCount) { + builder.addFieldInt8(8, modificationCount, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(9, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.endAccountPropertiesMosaicTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.finishAccountPropertiesMosaicTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AddressAliasTransactionBuffer.ts b/src/infrastructure/buffers/AddressAliasTransactionBuffer.ts new file mode 100644 index 0000000000..48dd845503 --- /dev/null +++ b/src/infrastructure/buffers/AddressAliasTransactionBuffer.ts @@ -0,0 +1,479 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.AddressAliasTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AddressAliasTransactionBuffer} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AddressAliasTransactionBuffer=} obj + * @returns {Catapult.Buffers.AddressAliasTransactionBuffer} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.getRootAsAddressAliasTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AddressAliasTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.actionType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.namespaceId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.namespaceIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.namespaceIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.address = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.addressLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.addressArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startAddressAliasTransactionBuffer = function(builder) { + builder.startObject(10); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} actionType + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addActionType = function(builder, actionType) { + builder.addFieldInt8(7, actionType, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deltaOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addNamespaceId = function(builder, namespaceIdOffset) { + builder.addFieldOffset(8, namespaceIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createNamespaceIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startNamespaceIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addAddress = function(builder, addressOffset) { + builder.addFieldOffset(9, addressOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createAddressVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startAddressVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.endAddressAliasTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.finishAddressAliasTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AggregateTransactionBuffer.ts b/src/infrastructure/buffers/AggregateTransactionBuffer.ts new file mode 100644 index 0000000000..e2f9f68e83 --- /dev/null +++ b/src/infrastructure/buffers/AggregateTransactionBuffer.ts @@ -0,0 +1,425 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.AggregateTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AggregateTransactionBuffer} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AggregateTransactionBuffer=} obj + * @returns {Catapult.Buffers.AggregateTransactionBuffer} + */ +Catapult.Buffers.AggregateTransactionBuffer.getRootAsAggregateTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AggregateTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactionsSize = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactions = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactionsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactionsArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AggregateTransactionBuffer.startAggregateTransactionBuffer = function(builder) { + builder.startObject(9); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AggregateTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AggregateTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AggregateTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} transactionsSize + */ +Catapult.Buffers.AggregateTransactionBuffer.addTransactionsSize = function(builder, transactionsSize) { + builder.addFieldInt32(7, transactionsSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} transactionsOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addTransactions = function(builder, transactionsOffset) { + builder.addFieldOffset(8, transactionsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createTransactionsVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startTransactionsVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.endAggregateTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AggregateTransactionBuffer.finishAggregateTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/HashLockTransactionBuffer.ts b/src/infrastructure/buffers/HashLockTransactionBuffer.ts new file mode 100644 index 0000000000..ed4f0d4d8d --- /dev/null +++ b/src/infrastructure/buffers/HashLockTransactionBuffer.ts @@ -0,0 +1,571 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.HashLockTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.HashLockTransactionBuffer} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.HashLockTransactionBuffer=} obj + * @returns {Catapult.Buffers.HashLockTransactionBuffer} + */ +Catapult.Buffers.HashLockTransactionBuffer.getRootAsHashLockTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.HashLockTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicAmount = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicAmountLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicAmountArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.duration = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.durationLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.durationArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.hash = function(index) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.hashLength = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.hashArray = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.HashLockTransactionBuffer.startHashLockTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.HashLockTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.HashLockTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.HashLockTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(7, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicAmountOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addMosaicAmount = function(builder, mosaicAmountOffset) { + builder.addFieldOffset(8, mosaicAmountOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createMosaicAmountVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startMosaicAmountVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addDuration = function(builder, durationOffset) { + builder.addFieldOffset(9, durationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createDurationVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startDurationVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} hashOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addHash = function(builder, hashOffset) { + builder.addFieldOffset(10, hashOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createHashVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startHashVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.endHashLockTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.HashLockTransactionBuffer.finishHashLockTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts b/src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts new file mode 100644 index 0000000000..ee4d523f8d --- /dev/null +++ b/src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts @@ -0,0 +1,479 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicAliasTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicAliasTransactionBuffer} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicAliasTransactionBuffer=} obj + * @returns {Catapult.Buffers.MosaicAliasTransactionBuffer} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.getRootAsMosaicAliasTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicAliasTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.actionType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.namespaceId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.namespaceIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.namespaceIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startMosaicAliasTransactionBuffer = function(builder) { + builder.startObject(10); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} actionType + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addActionType = function(builder, actionType) { + builder.addFieldInt8(7, actionType, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deltaOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addNamespaceId = function(builder, namespaceIdOffset) { + builder.addFieldOffset(8, namespaceIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createNamespaceIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startNamespaceIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(9, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.endMosaicAliasTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.finishMosaicAliasTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts b/src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts new file mode 100644 index 0000000000..eef8821885 --- /dev/null +++ b/src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts @@ -0,0 +1,582 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicCreationTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicCreationTransactionBuffer} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicCreationTransactionBuffer=} obj + * @returns {Catapult.Buffers.MosaicCreationTransactionBuffer} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.getRootAsMosaicCreationTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicCreationTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.nonce = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.nonceLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.nonceArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.numOptionalProperties = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.flags = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.divisibility = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.indicateDuration = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.duration = function(index) { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.durationLength = function() { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.durationArray = function() { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startMosaicCreationTransactionBuffer = function(builder) { + builder.startObject(14); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} nonce + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addNonce = function(builder, nonceOffset) { + + builder.addFieldOffset(7, nonceOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createNonceVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startNonceVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(8, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numOptionalProperties + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addNumOptionalProperties = function(builder, numOptionalProperties) { + builder.addFieldInt8(9, numOptionalProperties, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} flags + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addFlags = function(builder, flags) { + builder.addFieldInt8(10, flags, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} divisibility + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addDivisibility = function(builder, divisibility) { + builder.addFieldInt8(11, divisibility, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} indicateDuration + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addIndicateDuration = function(builder, indicateDuration) { + builder.addFieldInt8(12, indicateDuration, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addDuration = function(builder, durationOffset) { + builder.addFieldOffset(13, durationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createDurationVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startDurationVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.endMosaicCreationTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.finishMosaicCreationTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts b/src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts new file mode 100644 index 0000000000..0297f46688 --- /dev/null +++ b/src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts @@ -0,0 +1,479 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicSupplyChangeTransactionBuffer} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicSupplyChangeTransactionBuffer=} obj + * @returns {Catapult.Buffers.MosaicSupplyChangeTransactionBuffer} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.getRootAsMosaicSupplyChangeTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicSupplyChangeTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.direction = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.delta = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deltaLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deltaArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startMosaicSupplyChangeTransactionBuffer = function(builder) { + builder.startObject(10); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(7, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} direction + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addDirection = function(builder, direction) { + builder.addFieldInt8(8, direction, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deltaOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addDelta = function(builder, deltaOffset) { + builder.addFieldOffset(9, deltaOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createDeltaVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startDeltaVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.endMosaicSupplyChangeTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.finishMosaicSupplyChangeTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts b/src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts new file mode 100644 index 0000000000..14376de447 --- /dev/null +++ b/src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts @@ -0,0 +1,571 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.CosignatoryModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.CosignatoryModificationBuffer} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.CosignatoryModificationBuffer=} obj + * @returns {Catapult.Buffers.CosignatoryModificationBuffer} + */ +Catapult.Buffers.CosignatoryModificationBuffer.getRootAsCosignatoryModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.CosignatoryModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.cosignatoryPublicKey = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.cosignatoryPublicKeyLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.cosignatoryPublicKeyArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.CosignatoryModificationBuffer.startCosignatoryModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.CosignatoryModificationBuffer.addType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} cosignatoryPublicKeyOffset + */ +Catapult.Buffers.CosignatoryModificationBuffer.addCosignatoryPublicKey = function(builder, cosignatoryPublicKeyOffset) { + builder.addFieldOffset(1, cosignatoryPublicKeyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.CosignatoryModificationBuffer.createCosignatoryPublicKeyVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.CosignatoryModificationBuffer.startCosignatoryPublicKeyVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.CosignatoryModificationBuffer.endCosignatoryModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.MultisigModificationTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MultisigModificationTransactionBuffer} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MultisigModificationTransactionBuffer=} obj + * @returns {Catapult.Buffers.MultisigModificationTransactionBuffer} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.getRootAsMultisigModificationTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MultisigModificationTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.minRemovalDelta = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.minApprovalDelta = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.numModifications = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.CosignatoryModificationBuffer=} obj + * @returns {Catapult.Buffers.CosignatoryModificationBuffer} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? (obj || new Catapult.Buffers.CosignatoryModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startMultisigModificationTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} minRemovalDelta + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addMinRemovalDelta = function(builder, minRemovalDelta) { + builder.addFieldInt8(7, minRemovalDelta, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} minApprovalDelta + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addMinApprovalDelta = function(builder, minApprovalDelta) { + builder.addFieldInt8(8, minApprovalDelta, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numModifications + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addNumModifications = function(builder, numModifications) { + builder.addFieldInt8(9, numModifications, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(10, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.endMultisigModificationTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.finishMultisigModificationTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts b/src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts new file mode 100644 index 0000000000..47e9657a44 --- /dev/null +++ b/src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts @@ -0,0 +1,512 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.NamespaceCreationTransactionBuffer} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.NamespaceCreationTransactionBuffer=} obj + * @returns {Catapult.Buffers.NamespaceCreationTransactionBuffer} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.getRootAsNamespaceCreationTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.NamespaceCreationTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.durationParentId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.durationParentIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.durationParentIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceNameSize = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceName = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startNamespaceCreationTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} namespaceType + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceType = function(builder, namespaceType) { + builder.addFieldInt8(7, namespaceType, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationParentIdOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addDurationParentId = function(builder, durationParentIdOffset) { + builder.addFieldOffset(8, durationParentIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createDurationParentIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startDurationParentIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} namespaceIdOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceId = function(builder, namespaceIdOffset) { + builder.addFieldOffset(9, namespaceIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createNamespaceIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startNamespaceIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} namespaceNameSize + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceNameSize = function(builder, namespaceNameSize) { + builder.addFieldInt8(10, namespaceNameSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} namespaceNameOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceName = function(builder, namespaceNameOffset) { + builder.addFieldOffset(11, namespaceNameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.endNamespaceCreationTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.finishNamespaceCreationTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/SecretLockTransactionBuffer.ts b/src/infrastructure/buffers/SecretLockTransactionBuffer.ts new file mode 100644 index 0000000000..4036cdd4c2 --- /dev/null +++ b/src/infrastructure/buffers/SecretLockTransactionBuffer.ts @@ -0,0 +1,641 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.SecretLockTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.SecretLockTransactionBuffer} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.SecretLockTransactionBuffer=} obj + * @returns {Catapult.Buffers.SecretLockTransactionBuffer} + */ +Catapult.Buffers.SecretLockTransactionBuffer.getRootAsSecretLockTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.SecretLockTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicAmount = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicAmountLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicAmountArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.duration = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.durationLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.durationArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.hashAlgorithm = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.secret = function(index) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.secretLength = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.secretArray = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.recipient = function(index) { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.recipientLength = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.recipientArray = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSecretLockTransactionBuffer = function(builder) { + builder.startObject(13); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.SecretLockTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.SecretLockTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(7, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicAmountOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addMosaicAmount = function(builder, mosaicAmountOffset) { + builder.addFieldOffset(8, mosaicAmountOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createMosaicAmountVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startMosaicAmountVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addDuration = function(builder, durationOffset) { + builder.addFieldOffset(9, durationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createDurationVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startDurationVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} hashAlgorithm + */ +Catapult.Buffers.SecretLockTransactionBuffer.addHashAlgorithm = function(builder, hashAlgorithm) { + builder.addFieldInt8(10, hashAlgorithm, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} secretOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSecret = function(builder, secretOffset) { + builder.addFieldOffset(11, secretOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createSecretVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSecretVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} recipientOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addRecipient = function(builder, recipientOffset) { + builder.addFieldOffset(12, recipientOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createRecipientVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startRecipientVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.endSecretLockTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.SecretLockTransactionBuffer.finishSecretLockTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/SecretProofTransactionBuffer.ts b/src/infrastructure/buffers/SecretProofTransactionBuffer.ts new file mode 100644 index 0000000000..570f57a886 --- /dev/null +++ b/src/infrastructure/buffers/SecretProofTransactionBuffer.ts @@ -0,0 +1,549 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.SecretProofTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.SecretProofTransactionBuffer} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.SecretProofTransactionBuffer=} obj + * @returns {Catapult.Buffers.SecretProofTransactionBuffer} + */ +Catapult.Buffers.SecretProofTransactionBuffer.getRootAsSecretProofTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.SecretProofTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.hashAlgorithm = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.secret = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.secretLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.secretArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.recipient = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.recipientLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.recipientArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proofSize = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proof = function(index) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proofLength = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proofArray = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSecretProofTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.SecretProofTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.SecretProofTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} hashAlgorithm + */ +Catapult.Buffers.SecretProofTransactionBuffer.addHashAlgorithm = function(builder, hashAlgorithm) { + builder.addFieldInt8(7, hashAlgorithm, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} secretOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSecret = function(builder, secretOffset) { + builder.addFieldOffset(8, secretOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createSecretVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSecretVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} recipientOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addRecipient = function(builder, recipientOffset) { + builder.addFieldOffset(9, recipientOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createRecipientVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startRecipientVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} proofSize + */ +Catapult.Buffers.SecretProofTransactionBuffer.addProofSize = function(builder, proofSize) { + builder.addFieldInt16(10, proofSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} proofOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addProof = function(builder, proofOffset) { + builder.addFieldOffset(11, proofOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createProofVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startProofVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.endSecretProofTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.SecretProofTransactionBuffer.finishSecretProofTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/TransferTransactionBuffer.ts b/src/infrastructure/buffers/TransferTransactionBuffer.ts new file mode 100644 index 0000000000..05be19edfb --- /dev/null +++ b/src/infrastructure/buffers/TransferTransactionBuffer.ts @@ -0,0 +1,785 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MessageBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MessageBuffer} + */ +Catapult.Buffers.MessageBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MessageBuffer=} obj + * @returns {Catapult.Buffers.MessageBuffer} + */ +Catapult.Buffers.MessageBuffer.getRootAsMessageBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MessageBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MessageBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MessageBuffer.prototype.payload = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MessageBuffer.prototype.payloadLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MessageBuffer.prototype.payloadArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MessageBuffer.startMessageBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MessageBuffer.addType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} payloadOffset + */ +Catapult.Buffers.MessageBuffer.addPayload = function(builder, payloadOffset) { + builder.addFieldOffset(1, payloadOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MessageBuffer.createPayloadVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MessageBuffer.startPayloadVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MessageBuffer.endMessageBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicBuffer} + */ +Catapult.Buffers.MosaicBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicBuffer=} obj + * @returns {Catapult.Buffers.MosaicBuffer} + */ +Catapult.Buffers.MosaicBuffer.getRootAsMosaicBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.id = function(index) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.idLength = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicBuffer.prototype.idArray = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.amount = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.amountLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicBuffer.prototype.amountArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicBuffer.startMosaicBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} idOffset + */ +Catapult.Buffers.MosaicBuffer.addId = function(builder, idOffset) { + builder.addFieldOffset(0, idOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicBuffer.createIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicBuffer.startIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} amountOffset + */ +Catapult.Buffers.MosaicBuffer.addAmount = function(builder, amountOffset) { + builder.addFieldOffset(1, amountOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicBuffer.createAmountVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicBuffer.startAmountVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicBuffer.endMosaicBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.TransferTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.TransferTransactionBuffer} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.TransferTransactionBuffer=} obj + * @returns {Catapult.Buffers.TransferTransactionBuffer} + */ +Catapult.Buffers.TransferTransactionBuffer.getRootAsTransferTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.TransferTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.recipient = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.recipientLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.recipientArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.messageSize = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.numMosaics = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {Catapult.Buffers.MessageBuffer=} obj + * @returns {Catapult.Buffers.MessageBuffer|null} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.message = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? (obj || new Catapult.Buffers.MessageBuffer).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.MosaicBuffer=} obj + * @returns {Catapult.Buffers.MosaicBuffer} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.mosaics = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? (obj || new Catapult.Buffers.MosaicBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.mosaicsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.TransferTransactionBuffer.startTransferTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.TransferTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.TransferTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.TransferTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} recipientOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addRecipient = function(builder, recipientOffset) { + builder.addFieldOffset(7, recipientOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createRecipientVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startRecipientVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} messageSize + */ +Catapult.Buffers.TransferTransactionBuffer.addMessageSize = function(builder, messageSize) { + builder.addFieldInt16(8, messageSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numMosaics + */ +Catapult.Buffers.TransferTransactionBuffer.addNumMosaics = function(builder, numMosaics) { + builder.addFieldInt8(9, numMosaics, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} messageOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addMessage = function(builder, messageOffset) { + builder.addFieldOffset(10, messageOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicsOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addMosaics = function(builder, mosaicsOffset) { + builder.addFieldOffset(11, mosaicsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createMosaicsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startMosaicsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.endTransferTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.TransferTransactionBuffer.finishTransferTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/schemas/AccountLinkTransactionSchema.ts b/src/infrastructure/schemas/AccountLinkTransactionSchema.ts new file mode 100644 index 0000000000..5a0e3be1ba --- /dev/null +++ b/src/infrastructure/schemas/AccountLinkTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/AccountLinkTransaction + */ + +/** + * Account Link schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('remoteAccountKey'), + ubyte('linkAction') +]); +export default schema; diff --git a/src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts b/src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts new file mode 100644 index 0000000000..288fb34f23 --- /dev/null +++ b/src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + ushort, + tableArray, + uint +} from './Schema'; + +/** + * @module schema/AccountPropertiesAddressModificationTransactionSchema + */ + +/** + * Account properties address transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('propertyType'), + ubyte('modificationCount'), + tableArray('modifications', [ + ubyte('modificationType'), + array('value', TypeSize.BYTE) + ]) +]); diff --git a/src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts b/src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts new file mode 100644 index 0000000000..5c2373b1cc --- /dev/null +++ b/src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + ushort, + tableArray, + uint +} from './Schema'; + +/** + * @module schema/AccountPropertiesEntityTypeModificationTransactionSchema + */ + +/** + * Account properties address transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('propertyType'), + ubyte('modificationCount'), + tableArray('modifications', [ + ubyte('modificationType'), + ushort('value') + ]) +]); diff --git a/src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts b/src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts new file mode 100644 index 0000000000..ce323b9e8c --- /dev/null +++ b/src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + ushort, + tableArray, + uint +} from './Schema'; + +/** + * @module schema/AccountPropertiesMosaicModificationTransactionSchema + */ + +/** + * Account properties address transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('propertyType'), + ubyte('modificationCount'), + tableArray('modifications', [ + ubyte('modificationType'), + array('value', TypeSize.INT) + ]) +]); diff --git a/src/infrastructure/schemas/AddressAliasTransactionSchema.ts b/src/infrastructure/schemas/AddressAliasTransactionSchema.ts new file mode 100644 index 0000000000..4a9ceb4d25 --- /dev/null +++ b/src/infrastructure/schemas/AddressAliasTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/AddressAliasTransactionSchema + */ + +/** + * Address alias transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('actionType'), + array('namespaceId', TypeSize.INT), + array('address', TypeSize.BYTE) +]); diff --git a/src/infrastructure/schemas/AggregateTransactionSchema.ts b/src/infrastructure/schemas/AggregateTransactionSchema.ts new file mode 100644 index 0000000000..f27bc0e142 --- /dev/null +++ b/src/infrastructure/schemas/AggregateTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + uint, + ushort +} from './Schema'; + +/** + * @module schema/AggregateTransactionSchema + */ + +/** + * Aggregate transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + uint('transactionsSize'), + array('transactions') +]); + +export default schema; diff --git a/src/infrastructure/schemas/HashLockTransactionSchema.ts b/src/infrastructure/schemas/HashLockTransactionSchema.ts new file mode 100644 index 0000000000..2efbf4ffaa --- /dev/null +++ b/src/infrastructure/schemas/HashLockTransactionSchema.ts @@ -0,0 +1,45 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + uint, + ushort +} from './Schema'; + +/** + * @module schema/HashLockTransactionSchema + */ + +/** + * Hash lock transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('mosaicId', TypeSize.INT), + array('mosaicAmount', TypeSize.INT), + array('duration', TypeSize.INT), + array('hash') +]); +export default schema; diff --git a/src/infrastructure/schemas/MosaicAliasTransactionSchema.ts b/src/infrastructure/schemas/MosaicAliasTransactionSchema.ts new file mode 100644 index 0000000000..b8a69b4c3e --- /dev/null +++ b/src/infrastructure/schemas/MosaicAliasTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MosaicAliasTransactionSchema + */ + +/** + * Mosaic alias transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('actionType'), + array('namespaceId', TypeSize.INT), + array('mosaicId', TypeSize.INT) +]); diff --git a/src/infrastructure/schemas/MosaicCreationTransactionSchema.ts b/src/infrastructure/schemas/MosaicCreationTransactionSchema.ts new file mode 100644 index 0000000000..e9d947652a --- /dev/null +++ b/src/infrastructure/schemas/MosaicCreationTransactionSchema.ts @@ -0,0 +1,63 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MosaicCreationTransactionSchema + */ + +/** + * Mosaic definition creation transaction schema + * @const {module:schema/Schema} + */ +export const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('nonce', TypeSize.BYTE), + array('mosaicId', TypeSize.INT), + ubyte('numOptionalProperties'), + ubyte('flags'), + ubyte('divisibility'), + ubyte('indicateDuration'), + array('duration', TypeSize.INT) +]); + +export const schemaNoDuration = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('nonce', TypeSize.BYTE), + array('mosaicId', TypeSize.INT), + ubyte('numOptionalProperties'), + ubyte('flags'), + ubyte('divisibility') +]); diff --git a/src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts b/src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts new file mode 100644 index 0000000000..19df7503b8 --- /dev/null +++ b/src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MosaicSupplyChangeTransactionSchema + */ + +/** + * Mosaic supply change transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('mosaicId', TypeSize.INT), + ubyte('direction'), + array('delta', TypeSize.INT) +]); diff --git a/src/infrastructure/schemas/MultisigModificationTransactionSchema.ts b/src/infrastructure/schemas/MultisigModificationTransactionSchema.ts new file mode 100644 index 0000000000..91beb8efc6 --- /dev/null +++ b/src/infrastructure/schemas/MultisigModificationTransactionSchema.ts @@ -0,0 +1,49 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + tableArray, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MultigAggregateModificationTransactionSchema + */ + +/** + * Multisig aggregate modification transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('minRemovalDelta'), + ubyte('minApprovalDelta'), + ubyte('numModifications'), + tableArray('modifications', [ + ubyte('type'), + array('cosignatoryPublicKey') + ]) +]); diff --git a/src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts b/src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts new file mode 100644 index 0000000000..7694dddc5e --- /dev/null +++ b/src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts @@ -0,0 +1,47 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + string, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/NamespaceCreationTransactionSchema + */ + +/** + * Provision namespace transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('namespaceType'), + array('durationParentId', TypeSize.INT), + array('namespaceId', TypeSize.INT), + ubyte('namespaceNameSize'), + string('name') +]); diff --git a/src/infrastructure/schemas/Schema.ts b/src/infrastructure/schemas/Schema.ts new file mode 100644 index 0000000000..212378e39e --- /dev/null +++ b/src/infrastructure/schemas/Schema.ts @@ -0,0 +1,374 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* eslint-disable no-use-before-define */ + +/** + * In bytes + * @type {{BYTE: number, SHORT: number, INT: number}} + */ +export const TypeSize = { + BYTE: 1, + SHORT: 2, + INT: 4, +}; + +/** + * @param {string} name Attribute name + * @returns {ScalarAttribute} return ScalarAttribute Instance + */ +export const ubyte = (name) => { + return new ScalarAttribute(name, TypeSize.BYTE); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const byte = (name) => { + return new ScalarAttribute(name, TypeSize.BYTE); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const ushort = (name) => { + return new ScalarAttribute(name, TypeSize.SHORT); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const short = (name) => { + return new ScalarAttribute(name, TypeSize.SHORT); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const uint = (name) => { + return new ScalarAttribute(name, TypeSize.INT); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const int = (name) => { + return new ScalarAttribute(name, TypeSize.INT); +}; + +/** + * + * @param {string} name Attribute Name + * @param {number} typeSize Attribute Byte Size + * @returns {ArrayAttribute} ArrayAttribute Instance + */ +export const array = (name, typeSize = TypeSize.BYTE) => { + return new ArrayAttribute(name, typeSize); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ArrayAttribute} ArrayAttribute Instance + */ +export const string = (name) => { + return array(name); +}; + +/** + * + * @param {string} name Attribute Name + * @param {module:schema/Schema} schema Table Specific Schema definition + * @returns {TableAttribute} TableAttribute Instance + */ +export const table = (name, schema) => { + return new TableAttribute(name, schema); +}; + +/** + * + * @param {string} name Attribute Name + * @param {module:schema/Schema} schema Schema Definition + * @returns {TableArrayAttribute} TableAttribute Instance + */ +export const tableArray = (name, schema) => { + return new TableArrayAttribute(name, schema); +}; + +/* eslint-disable */ +const readInt32 = (offset, bytes) => { + return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24; +}; + +const readInt16 = (offset, bytes) => { + return bytes[offset] | bytes[offset + 1] << 8; +}; + +const __offset = (val0, fieldPos, bytes) => { + const vtable = val0 - readInt32(val0, bytes); + return fieldPos < readInt16(vtable, bytes) ? readInt16(vtable + fieldPos, bytes) : 0; +}; + +const __vector_length = (offset, bytes) => { + return readInt32(offset + readInt32(offset, bytes), bytes); +}; + +const __indirect = (offset, bytes) => { + return offset + readInt32(offset, bytes); +}; + +const __vector = (offset, bytes) => { + return offset + readInt32(offset, bytes) + 4; +}; + +const findVector = (val0, fieldPos, bytes, size) => { + const offset = __offset(val0, fieldPos, bytes); + const offsetLong = offset + val0; + const vecStart = __vector(offsetLong, bytes); + const vecLength = __vector_length(offsetLong, bytes) * (size ? size : 1); + return offset ? bytes.slice(vecStart, vecStart + vecLength) : 0; +}; + +const findParam = (val0, fieldPos, bytes, numBytes) => { + const offset = __offset(val0, fieldPos, bytes); + return offset ? bytes.slice(offset + val0, offset + val0 + numBytes) : 0; +}; + +const findObjectStartPosition = (val0, fieldPos, bytes) => { + const offset = __offset(val0, fieldPos, bytes); + return __indirect(offset + val0, bytes); +}; + +const findArrayLength = (val0, fieldPos, bytes) => { + const offset = __offset(val0, fieldPos, bytes); + return offset ? __vector_length(val0 + offset, bytes) : 0; +}; + +const findObjectArrayElementStartPosition = (val0, fieldPos, bytes, index) => { + const offset = __offset(val0, fieldPos, bytes); + const vector = __vector(val0 + offset, bytes); + return __indirect(vector + index * 4, bytes); +}; + +/** + * Schema + * @module schema/Schema + */ +export class Schema { + schemaDefinition; + /** + * @constructor + * @param {Array.} schemaDefinition Schema Definition + */ + constructor(schemaDefinition) { + this.schemaDefinition = schemaDefinition; + } + + /** + * + * @param {Uint8Array} bytes flatbuffers bytes + * @returns {Uint8Array} catapult buffer + */ + serialize(bytes) { + let i = 0; + let resultBytes = []; + while (i < this.schemaDefinition.length) { + resultBytes = resultBytes.concat(this.schemaDefinition[i].serialize(bytes, 4 + (i * 2))); + i++; + } + return resultBytes; + } + + /** + * @param {Uint8Array} bytes flatbuffer bytes + * @returns {Array} Array with field name + payload + */ + debugSerialize(bytes) { + let i = 0; + let result: any = []; + while (i < this.schemaDefinition.length) { + result = result.concat({ + name: this.schemaDefinition[i].name, + bytes: this.schemaDefinition[i].debugSerialize(bytes, 4 + i * 2), + }); + i++; + } + return result; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class Attribute { + name: any; + /** + * @constructor + * @param {string} name schema attribute name + */ + constructor(name) { + this.name = name; + } + + /** + * + * @param {Uint8Array} buffer flatbuffer bytes + * @param {number} position attribute possition in flatbuffer bytes + * @param {number} val0 position in case that it is an inner object + */ + serialize(buffer, position, val0 = undefined) { + throw new Error('Unimplemented method'); + } + + /** + * @suppress warnings + * @param {Uint8Array} buffer buffer flatbuffer bytes + * @param {number} position attribute possition in flatbuffer bytes + * @param {number} val0 position in case that it is an inner object + */ + debugSerialize(buffer, position, val0 = undefined) { + throw new Error('Unimplemented method'); + } +} + +// tslint:disable-next-line:max-classes-per-file +export class ScalarAttribute extends Attribute { + typeSize: any; + name: any; + /** + * @constructor + * @param {string} name schema attribute name + * @param {number} typeSize + */ + constructor(name, typeSize) { + super(name); + this.typeSize = typeSize; + } + + serialize(buffer, position, val0 = undefined) { + return findParam(val0 ? val0 : buffer[0], position, buffer, this.typeSize); + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class ArrayAttribute extends Attribute { + typeSize: any; + name: any; + /** + * @constructor + * @param name - {string} + * @param typeSize - {TypeSize} + */ + constructor(name, typeSize) { + super(name); + this.typeSize = typeSize; + } + + serialize(buffer, position, val0 = undefined) { + return findVector(val0 ? val0 : buffer[0], position, buffer, this.typeSize); + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class TableAttribute extends Attribute { + schema: any; + name: any; + /** + * + * @param {string} name + * @param {module:schema/Schema} schema + */ + constructor(name, schema) { + super(name); + this.schema = schema; + } + + serialize(bytes, position, val0 = undefined) { + let result = []; + const messageStartPosition = findObjectStartPosition(val0 ? val0 : bytes[0], position, bytes); + let i = 0; + while (i < this.schema.length) { + result = result.concat(this.schema[i].serialize(bytes, 4 + i * 2, messageStartPosition)); + i++; + } + return result; + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class TableArrayAttribute extends Attribute { + schema: any; + name: any; + /** + * @constructor + * @param {string} name + * @param {module:schema/Schema} schema + */ + constructor(name, schema) { + super(name); + this.schema = schema; + } + + serialize(bytes, position, val0 = undefined) { + let result = []; + const arrayLength = findArrayLength(val0 ? val0 : bytes[0], position, bytes); + let i = 0; + while (i < arrayLength) { + const startArrayPosition = findObjectArrayElementStartPosition(val0 ? val0 : bytes[0], position, bytes, i); + for (let j = 0; j < this.schema.length; ++j) { + result = result.concat(this.schema[j].serialize(bytes, 4 + j * 2, startArrayPosition)); + } + i++; + } + return result; + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} diff --git a/src/infrastructure/schemas/SecretLockTransactionSchema.ts b/src/infrastructure/schemas/SecretLockTransactionSchema.ts new file mode 100644 index 0000000000..046f02c178 --- /dev/null +++ b/src/infrastructure/schemas/SecretLockTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/SecretLockTransactionSchema + */ + +/** + * Secret lock transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('mosaicId', TypeSize.INT), + array('mosaicAmount', TypeSize.INT), + array('duration', TypeSize.INT), + ubyte('hashAlgorithm'), + array('secret'), + array('recipient') +]); +export default schema; diff --git a/src/infrastructure/schemas/SecretProofTransactionSchema.ts b/src/infrastructure/schemas/SecretProofTransactionSchema.ts new file mode 100644 index 0000000000..db03f6eaf4 --- /dev/null +++ b/src/infrastructure/schemas/SecretProofTransactionSchema.ts @@ -0,0 +1,47 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/SecretProofTransactionSchema + */ + +/** + * Secret proof transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('hashAlgorithm'), + array('secret'), + array('recipient'), + ushort('proofSize'), + array('proof') +]); +export default schema; diff --git a/src/infrastructure/schemas/TransferTransactionSchema.ts b/src/infrastructure/schemas/TransferTransactionSchema.ts new file mode 100644 index 0000000000..eb8efdfd4e --- /dev/null +++ b/src/infrastructure/schemas/TransferTransactionSchema.ts @@ -0,0 +1,55 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + table, + tableArray, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/TransferTransactionSchema + */ + +/** + * Transfer transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('recipient'), + ushort('messageSize'), + ubyte('numMosaics'), + table('message', [ + ubyte('type'), + array('payload') + ]), + tableArray('mosaics', [ + array('id', TypeSize.INT), + array('amount', TypeSize.INT) + ]) +]); +export default schema; From 4262dab1bdedcfe2970d64278d77d4f97e0d656f Mon Sep 17 00:00:00 2001 From: Steven Liu Date: Tue, 11 Jun 2019 22:27:25 +0100 Subject: [PATCH 5/7] Added #94 Merged crypto implementation --- e2e/infrastructure/TransactionHttp.spec.ts | 27 +- index.ts | 1 + src/core/crypto/Crypto.ts | 318 ++++++++ src/core/crypto/KeyPair.ts | 74 ++ src/core/crypto/SHA3Hasher.ts | 70 ++ src/core/crypto/Utilities.ts | 227 ++++++ src/core/crypto/index.ts | 18 + src/core/crypto/nacl_catapult.ts | 852 +++++++++++++++++++++ src/model/account/Account.ts | 4 +- src/model/account/PublicAccount.ts | 2 +- src/model/model.ts | 1 + src/model/mosaic/MosaicNonce.ts | 6 +- src/model/transaction/EncryptedMessage.ts | 6 +- src/model/wallet/EncryptedPrivateKey.ts | 5 +- src/model/wallet/SimpleWallet.ts | 8 +- src/model/wallet/WalletAlgorithm.ts | 22 + 16 files changed, 1611 insertions(+), 30 deletions(-) create mode 100644 src/core/crypto/Crypto.ts create mode 100644 src/core/crypto/KeyPair.ts create mode 100644 src/core/crypto/SHA3Hasher.ts create mode 100644 src/core/crypto/Utilities.ts create mode 100644 src/core/crypto/index.ts create mode 100644 src/core/crypto/nacl_catapult.ts create mode 100644 src/model/wallet/WalletAlgorithm.ts diff --git a/e2e/infrastructure/TransactionHttp.spec.ts b/e2e/infrastructure/TransactionHttp.spec.ts index f27931a440..ce067eb5ea 100644 --- a/e2e/infrastructure/TransactionHttp.spec.ts +++ b/e2e/infrastructure/TransactionHttp.spec.ts @@ -17,7 +17,7 @@ import {assert, expect} from 'chai'; import * as CryptoJS from 'crypto-js'; import {ChronoUnit} from 'js-joda'; import {keccak_256, sha3_256} from 'js-sha3'; -import {nacl_catapult} from 'nem2-library'; +import {Crypto} from '../../src/core/crypto'; import { Convert as convert } from '../../src/core/format'; import {AccountHttp} from '../../src/infrastructure/AccountHttp'; import { NamespaceHttp } from '../../src/infrastructure/infrastructure'; @@ -67,7 +67,6 @@ import {Transaction} from '../../src/model/transaction/Transaction'; import {TransactionType} from '../../src/model/transaction/TransactionType'; import {TransferTransaction} from '../../src/model/transaction/TransferTransaction'; import {UInt64} from '../../src/model/UInt64'; - describe('TransactionHttp', () => { let transactionHash; let transactionId; @@ -993,7 +992,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Sha3_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1029,7 +1028,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Sha3_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1063,7 +1062,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Keccak_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1093,7 +1092,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Keccak_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1122,7 +1121,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('standalone', (done) => { - const secretSeed = String.fromCharCode.apply(null, nacl_catapult.randomBytes(20)); + const secretSeed = String.fromCharCode.apply(null, Crypto.randomBytes(20)); const secret = CryptoJS.RIPEMD160(CryptoJS.SHA256(secretSeed).toString(CryptoJS.enc.Hex)).toString(CryptoJS.enc.Hex); const secretLockTransaction = SecretLockTransaction.create( Deadline.create(), @@ -1154,7 +1153,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('aggregate', (done) => { - const secretSeed = String.fromCharCode.apply(null, nacl_catapult.randomBytes(20)); + const secretSeed = String.fromCharCode.apply(null, Crypto.randomBytes(20)); const secret = CryptoJS.RIPEMD160(CryptoJS.SHA256(secretSeed).toString(CryptoJS.enc.Hex)).toString(CryptoJS.enc.Hex); const secretLockTransaction = SecretLockTransaction.create( Deadline.create(), @@ -1195,7 +1194,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Hash_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1225,7 +1224,7 @@ describe('TransactionHttp', () => { NetworkCurrencyMosaic.createAbsolute(10), UInt64.fromUint(100), HashType.Op_Hash_256, - sha3_256.create().update(nacl_catapult.randomBytes(20)).hex(), + sha3_256.create().update(Crypto.randomBytes(20)).hex(), account2.address, NetworkType.MIJIN_TEST, ); @@ -1254,7 +1253,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('standalone', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = sha3_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); @@ -1305,7 +1304,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('aggregate', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = sha3_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); const secretLockTransaction = SecretLockTransaction.create( @@ -1353,7 +1352,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('standalone', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = keccak_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); const secretLockTransaction = SecretLockTransaction.create( @@ -1397,7 +1396,7 @@ describe('TransactionHttp', () => { return listener.close(); }); it('aggregate', (done) => { - const secretSeed = nacl_catapult.randomBytes(20); + const secretSeed = Crypto.randomBytes(20); const secret = keccak_256.create().update(secretSeed).hex(); const proof = convert.uint8ToHex(secretSeed); const secretLockTransaction = SecretLockTransaction.create( diff --git a/index.ts b/index.ts index 1146495f42..1239bbb0f5 100644 --- a/index.ts +++ b/index.ts @@ -19,3 +19,4 @@ export * from './src/model/model'; export * from './src/service/service'; export * from './src/core/utils/utility'; export * from './src/core/format'; +export * from './src/core/crypto'; diff --git a/src/core/crypto/Crypto.ts b/src/core/crypto/Crypto.ts new file mode 100644 index 0000000000..0deef4f151 --- /dev/null +++ b/src/core/crypto/Crypto.ts @@ -0,0 +1,318 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { WalletAlgorithm } from '../../model/wallet/WalletAlgorithm'; +import { Convert as convert } from '../format/Convert'; +import { KeyPair } from './KeyPair'; +import * as utility from './Utilities'; +const CryptoJS = require('crypto-js'); +export class Crypto { + /** + * Encrypt a private key for mobile apps (AES_PBKF2) + * + * @param {string} password - A wallet password + * @param {string} privateKey - An account private key + * + * @return {object} - The encrypted data + */ + public static toMobileKey = (password, privateKey) => { + // Errors + if (!password || !privateKey) { throw new Error('Missing argument !'); } + // Processing + const salt = CryptoJS.lib.WordArray.random(256 / 8); + const key = CryptoJS.PBKDF2(password, salt, { + keySize: 256 / 32, + iterations: 2000, + }); + const iv = Crypto.randomBytes(16); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = CryptoJS.AES.encrypt(CryptoJS.enc.Hex.parse(privateKey), key, encIv); + // Result + return { + encrypted: convert.uint8ToHex(iv) + encrypted.ciphertext, + salt: salt.toString(), + }; + } + + /** + * Derive a private key from a password using count iterations of SHA3-256 + * + * @param {string} password - A wallet password + * @param {number} count - A number of iterations above 0 + * + * @return {object} - The derived private key + */ + public static derivePassSha = (password, count) => { + // Errors + if (!password) { throw new Error('Missing argument !'); } + if (!count || count <= 0) { throw new Error('Please provide a count number above 0'); } + // Processing + let data = password; + for (let i = 0; i < count; ++i) { + data = CryptoJS.SHA3(data, { + outputLength: 256, + }); + } + // Result + return { + priv: CryptoJS.enc.Hex.stringify(data), + }; + } + + /** + * Encrypt hex data using a key + * + * @param {string} data - An hex string + * @param {Uint8Array} key - An Uint8Array key + * + * @return {object} - The encrypted data + */ + public static encrypt = (data, key) => { + // Errors + if (!data || !key) { throw new Error('Missing argument !'); } + // Processing + const iv = Crypto.randomBytes(16); + const encKey = utility.ua2words(key, 32); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = CryptoJS.AES.encrypt(CryptoJS.enc.Hex.parse(data), encKey, encIv); + // Result + return { + ciphertext: encrypted.ciphertext, + iv, + key, + }; + } + + /** + * Decrypt data + * + * @param {object} data - An encrypted data object + * + * @return {string} - The decrypted hex string + */ + public static decrypt = (data) => { + // Errors + if (!data) { throw new Error('Missing argument !'); } + // Processing + const encKey = utility.ua2words(data.key, 32); + const encIv = { + iv: utility.ua2words(data.iv, 16), + }; + // Result + return CryptoJS.enc.Hex.stringify(CryptoJS.AES.decrypt(data, encKey, encIv)); + } + + /** + * Reveal the private key of an account or derive it from the wallet password + * + * @param {object} common- An object containing password and privateKey field + * @param {object} walletAccount - A wallet account object + * @param {WalletAlgorithm} algo - A wallet algorithm + * + * @return {object|boolean} - The account private key in and object or false + */ + public static passwordToPrivateKey = (common, walletAccount, algo) => { + // Errors + if (!common || !common.password || !walletAccount || !algo) { throw new Error('Missing argument !'); } + // Processing + let r; + if (algo === WalletAlgorithm.Pass_6k) { // Brain wallets + if (!walletAccount.encrypted && !walletAccount.iv) { + // Account private key is generated simply using a passphrase so it has no encrypted and iv + r = Crypto.derivePassSha(common.password, 6000); + } else if (!walletAccount.encrypted || !walletAccount.iv) { + // Else if one is missing there is a problem + return false; + } else { + // Else child accounts have encrypted and iv so we decrypt + const pass = Crypto.derivePassSha(common.password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(walletAccount.encrypted), + iv: convert.hexToUint8(walletAccount.iv), + key: convert.hexToUint8(pass.priv), + }; + const d = Crypto.decrypt(obj); + r = { priv: d }; + } + } else if (algo === WalletAlgorithm.Pass_bip32) { // Wallets from PRNG + const pass = Crypto.derivePassSha(common.password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(walletAccount.encrypted), + iv: convert.hexToUint8(walletAccount.iv), + key: convert.hexToUint8(pass.priv), + }; + const d = Crypto.decrypt(obj); + r = { priv: d }; + } else if (algo === WalletAlgorithm.Pass_enc) { // Private Key wallets + const pass = Crypto.derivePassSha(common.password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(walletAccount.encrypted), + iv: convert.hexToUint8(walletAccount.iv), + key: convert.hexToUint8(pass.priv), + }; + const d = Crypto.decrypt(obj); + r = { priv: d }; + } else if (algo === WalletAlgorithm.Trezor) { // HW wallet + r = { priv: '' }; + common.isHW = true; + } else { + return false; + } + // Result + common.privateKey = r.priv; + return true; + } + + /** + * Generate a random key + * + * @return {Uint8Array} - A random key + */ + public static randomKey = () => { + return Crypto.randomBytes(32); + } + + /** + * Encode a private key using a password + * + * @param {string} privateKey - An hex private key + * @param {string} password - A password + * + * @return {object} - The encoded data + */ + public static encodePrivateKey = (privateKey, password) => { + // Errors + if (!privateKey || !password) { throw new Error('Missing argument !'); } + // Processing + const pass = Crypto.derivePassSha(password, 20); + const r = Crypto.encrypt(privateKey, convert.hexToUint8(pass.priv)); + // Result + return { + ciphertext: CryptoJS.enc.Hex.stringify(r.ciphertext), + iv: convert.uint8ToHex(r.iv), + }; + } + + /*** + * Encode a message, separated from encode() to help testing + * + * @param {string} senderPriv - A sender private key + * @param {string} recipientPub - A recipient public key + * @param {string} msg - A text message + * @param {Uint8Array} iv - An initialization vector + * @param {Uint8Array} salt - A salt + * + * @return {string} - The encoded message + */ + public static _encode = function(senderPriv, recipientPub, msg, iv, salt) { + // Errors + if (!senderPriv || !recipientPub || !msg || !iv || !salt) { throw new Error('Missing argument !'); } + // Processing + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(senderPriv); + const pk = convert.hexToUint8(recipientPub); + const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt), 32); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = CryptoJS.AES.encrypt(CryptoJS.enc.Hex.parse(convert.utf8ToHex(msg)), encKey, encIv); + // Result + const result = convert.uint8ToHex(salt) + convert.uint8ToHex(iv) + CryptoJS.enc.Hex.stringify(encrypted.ciphertext); + return result; + } + + /** + * Encode a message + * + * @param {string} senderPriv - A sender private key + * @param {string} recipientPub - A recipient public key + * @param {string} msg - A text message + * + * @return {string} - The encoded message + */ + public static encode = (senderPriv, recipientPub, msg) => { + // Errors + if (!senderPriv || !recipientPub || !msg) { throw new Error('Missing argument !'); } + // Processing + const iv = Crypto.randomBytes(16); + const salt = Crypto.randomBytes(32); + const encoded = Crypto._encode(senderPriv, recipientPub, msg, iv, salt); + // Result + return encoded; + } + + /** + * Decode an encrypted message payload + * + * @param {string} recipientPrivate - A recipient private key + * @param {string} senderPublic - A sender public key + * @param {Uint8Array} _payload - An encrypted message payload in bytes + * + * @return {string} - The decoded payload as hex + */ + public static _decode = (recipientPrivate, senderPublic, payload, iv, salt) => { + // Error + if (!recipientPrivate || !senderPublic || !payload) { throw new Error('Missing argument !'); } + // Processing + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(recipientPrivate); + const pk = convert.hexToUint8(senderPublic); + const encKey = utility.ua2words(KeyPair.deriveSharedKey(keyPair, pk, salt), 32); + const encIv = { + iv: utility.ua2words(iv, 16), + }; + const encrypted = { + ciphertext: utility.ua2words(payload, payload.length), + }; + const plain = CryptoJS.AES.decrypt(encrypted, encKey, encIv); + // Result + return CryptoJS.enc.Hex.stringify(plain); + } + + /** + * Decode an encrypted message payload + * + * @param {string} recipientPrivate - A recipient private key + * @param {string} senderPublic - A sender public key + * @param {string} _payload - An encrypted message payload + * + * @return {string} - The decoded payload as hex + */ + public static decode = (recipientPrivate, senderPublic, _payload) => { + // Error + if (!recipientPrivate || !senderPublic || !_payload) { throw new Error('Missing argument !'); } + // Processing + const binPayload = convert.hexToUint8(_payload); + const payload = new Uint8Array(binPayload.buffer, 48); + const salt = new Uint8Array(binPayload.buffer, 0, 32); + const iv = new Uint8Array(binPayload.buffer, 32, 16); + const decoded = Crypto._decode(recipientPrivate, senderPublic, payload, iv, salt); + return decoded; + } + + /** + * Generate random bytes by length + * @param {number} length - The length of the random bytes + * + * @return {Uint8Array} + */ + public static randomBytes = (length) => { + const crypto = require('crypto'); + return crypto.randomBytes(length); + } +} diff --git a/src/core/crypto/KeyPair.ts b/src/core/crypto/KeyPair.ts new file mode 100644 index 0000000000..b2b5a1bd1b --- /dev/null +++ b/src/core/crypto/KeyPair.ts @@ -0,0 +1,74 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { Convert as convert } from '../format'; +import * as Utility from './Utilities'; + +export class KeyPair { + /** + * Creates a key pair from a private key string. + * @param {string} privateKeyString A hex encoded private key string. + * @returns {module:crypto/keyPair~KeyPair} The key pair. + */ + public static createKeyPairFromPrivateKeyString = (privateKeyString) => { + const privateKey = convert.hexToUint8(privateKeyString); + if (Utility.Key_Size !== privateKey.length) { + throw Error(`private key has unexpected size: ${privateKey.length}`); + } + + const publicKey = Utility.catapult_crypto.extractPublicKey(privateKey, Utility.catapult_hash.func); + return { + privateKey, + publicKey, + }; + } + + /** + * Signs a data buffer with a key pair. + * @param {module:crypto/keyPair~KeyPair} keyPair The key pair to use for signing. + * @param {Uint8Array} data The data to sign. + * @returns {Uint8Array} The signature. + */ + public static sign = (keyPair, data) => { + return Utility.catapult_crypto.sign(data, keyPair.publicKey, keyPair.privateKey, Utility.catapult_hash.createHasher()); + } + + /** + * Verifies a signature. + * @param {module:crypto/keyPair~PublicKey} publicKey The public key to use for verification. + * @param {Uint8Array} data The data to verify. + * @param {Uint8Array} signature The signature to verify. + * @returns {boolean} true if the signature is verifiable, false otherwise. + */ + public static verify = (publicKey, data, signature) => { + return Utility.catapult_crypto.verify(publicKey, data, signature, Utility.catapult_hash.createHasher()); + } + + /** + * Creates a shared key given a key pair and an arbitrary public key. + * The shared key can be used for encrypted message passing between the two. + * @param {module:crypto/keyPair~KeyPair} keyPair The key pair for which to create the shared key. + * @param {module:crypto/keyPair~PublicKey} publicKey The public key for which to create the shared key. + * @param {Uint8Array} salt A salt that should be applied to the shared key. + * @returns {Uint8Array} The shared key. + */ + public static deriveSharedKey = (keyPair, publicKey, salt) => { + if (Utility.Key_Size !== salt.length) { + throw Error(`salt has unexpected size: ${salt.length}`); + } + + return Utility.catapult_crypto.deriveSharedKey(salt, keyPair.privateKey, publicKey, Utility.catapult_hash.func); + } +} diff --git a/src/core/crypto/SHA3Hasher.ts b/src/core/crypto/SHA3Hasher.ts new file mode 100644 index 0000000000..28ecc06847 --- /dev/null +++ b/src/core/crypto/SHA3Hasher.ts @@ -0,0 +1,70 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { sha3_256, sha3_512 } from 'js-sha3'; +import { Convert as convert, RawArray as array } from '../format'; + +export class SHA3Hasher { + /** + * Calculates the hash of data. + * @param {Uint8Array} dest The computed hash destination. + * @param {Uint8Array} data The data to hash. + * @param {numeric} length The hash length in bytes. + */ + public static func = (dest, data, length) => { + const hasher = SHA3Hasher.getHasher(length); + const hash = hasher.arrayBuffer(data); + array.copy(dest, array.uint8View(hash)); + } + + /** + * Creates a hasher object. + * @param {numeric} length The hash length in bytes. + * @returns {object} The hasher. + */ + public static createHasher = (length = 64) => { + let hash; + return { + reset: () => { + hash = SHA3Hasher.getHasher(length).create(); + }, + update: (data: any) => { + if (data instanceof Uint8Array) { + hash.update(data); + } else if ('string' === typeof data) { + hash.update(convert.hexToUint8(data)); + } else { + throw Error('unsupported data type'); + } + }, + finalize: (result: any) => { + array.copy(result, array.uint8View(hash.arrayBuffer())); + }, + }; + } + + /** + * Get a hasher instance. + * @param {numeric} length The hash length in bytes. + * @returns {object} The hasher. + */ + public static getHasher = (length = 64) => { + return { + 32: sha3_256, + 64: sha3_512, + } [length]; + } +} diff --git a/src/core/crypto/Utilities.ts b/src/core/crypto/Utilities.ts new file mode 100644 index 0000000000..487df065f7 --- /dev/null +++ b/src/core/crypto/Utilities.ts @@ -0,0 +1,227 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { RawArray as array } from '../format'; +import * as nacl from './nacl_catapult'; +import { SHA3Hasher as sha3Hasher } from './SHA3Hasher'; + +export const CryptoJS = require('crypto-js'); +export const Key_Size = 32; +export const Signature_Size = 64; +export const Half_Signature_Size = Signature_Size / 2; +export const Hash_Size = 64; +export const Half_Hash_Size = Hash_Size / 2; + +/** + * Convert an Uint8Array to WordArray + * + * @param {Uint8Array} ua - An Uint8Array + * @param {number} uaLength - The Uint8Array length + * + * @return {WordArray} + */ +export const ua2words = (ua, uaLength) => { + const temp: number[] = []; + for (let i = 0; i < uaLength; i += 4) { + const x = ua[i] * 0x1000000 + (ua[i + 1] || 0) * 0x10000 + (ua[i + 2] || 0) * 0x100 + (ua[i + 3] || 0); + temp.push((x > 0x7fffffff) ? x - 0x100000000 : x); + } + return CryptoJS.lib.WordArray.create(temp, uaLength); +}; + +/** + * Convert a wordArray to Uint8Array + * + * @param {Uint8Array} destUa - A destination Uint8Array + * @param {WordArray} cryptoWords - A wordArray + * + * @return {Uint8Array} + */ +export const words2ua = (destUa, cryptoWords) => { + for (let i = 0; i < destUa.length; i += 4) { + let v = cryptoWords.words[i / 4]; + if (v < 0) { v += 0x100000000; } + destUa[i] = (v >>> 24); + destUa[i + 1] = (v >>> 16) & 0xff; + destUa[i + 2] = (v >>> 8) & 0xff; + destUa[i + 3] = v & 0xff; + } + return destUa; +}; + +export const catapult_hash = { + func: sha3Hasher.func, + createHasher: sha3Hasher.createHasher, +}; + +// custom catapult crypto functions +export const catapult_crypto = (function() { + function clamp(d) { + d[0] &= 248; + d[31] &= 127; + d[31] |= 64; + } + + function prepareForScalarMult(sk, hashfunc) { + const d = new Uint8Array(Hash_Size); + hashfunc(d, sk); + clamp(d); + return d; + } + + const encodedSChecker = (function() { + const Is_Reduced = 1; + const Is_Zero = 2; + + function validateEncodedSPart(s) { + if (array.isZeroFilled(s)) { + return Is_Zero | Is_Reduced; + } + const copy = new Uint8Array(Signature_Size); + array.copy(copy, s, Half_Signature_Size); + + nacl.reduce(copy); + return array.deepEqual(s, copy, Half_Signature_Size) ? Is_Reduced : 0; + } + + return { + isCanonical: (s) => Is_Reduced === validateEncodedSPart(s), + + requireValid: (s) => { + if (0 === (validateEncodedSPart(s) & Is_Reduced)) { + throw Error('S part of signature invalid'); + } + }, + }; + })(); + + return { + extractPublicKey: (sk, hashfunc) => { + const c = nacl; + const d = prepareForScalarMult(sk, hashfunc); + + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const pk = new Uint8Array(Key_Size); + c.scalarbase(p, d); + c.pack(pk, p); + return pk; + }, + + sign: (m, pk, sk, hasher) => { + const c = nacl; + + const d = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(sk); + hasher.finalize(d); + clamp(d); + + const r = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(d.subarray(Half_Hash_Size)); + hasher.update(m); + hasher.finalize(r); + + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const signature = new Uint8Array(Signature_Size); + c.reduce(r); + c.scalarbase(p, r); + c.pack(signature, p); + + const h = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(signature.subarray(0, Half_Signature_Size)); + hasher.update(pk); + hasher.update(m); + hasher.finalize(h); + + c.reduce(h); + + // muladd + const x = new Float64Array(Hash_Size); + array.copy(x, r, Half_Hash_Size); + + for (let i = 0; i < Half_Hash_Size; ++i) { + for (let j = 0; j < Half_Hash_Size; ++j) { + x[i + j] += h[i] * d[j]; + } + } + + c.modL(signature.subarray(Half_Signature_Size), x); + encodedSChecker.requireValid(signature.subarray(Half_Signature_Size)); + return signature; + }, + + verify: (pk, m, signature, hasher) => { + // reject non canonical signature + if (!encodedSChecker.isCanonical(signature.subarray(Half_Signature_Size))) { + return false; + } + + // reject weak (zero) public key + if (array.isZeroFilled(pk)) { + return false; + } + + const c = nacl; + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const q = [c.gf(), c.gf(), c.gf(), c.gf()]; + + if (c.unpackneg(q, pk)) { + return false; + } + + const h = new Uint8Array(Hash_Size); + hasher.reset(); + hasher.update(signature.subarray(0, Half_Signature_Size)); + hasher.update(pk); + hasher.update(m); + hasher.finalize(h); + + c.reduce(h); + c.scalarmult(p, q, h); + + const t = new Uint8Array(Signature_Size); + c.scalarbase(q, signature.subarray(Half_Signature_Size)); + c.add(p, q); + c.pack(t, p); + + return 0 === c.crypto_verify_32(signature, 0, t, 0); + }, + + deriveSharedKey: (salt, sk, pk, hashfunc) => { + const c = nacl; + const d = prepareForScalarMult(sk, hashfunc); + + // sharedKey = pack(p = d (derived from sk) * q (derived from pk)) + const q = [c.gf(), c.gf(), c.gf(), c.gf()]; + const p = [c.gf(), c.gf(), c.gf(), c.gf()]; + const sharedKey = new Uint8Array(Key_Size); + c.unpackneg(q, pk); + c.scalarmult(p, q, d); + c.pack(sharedKey, p); + + // salt the shared key + for (let i = 0; i < Key_Size; ++i) { + sharedKey[i] ^= salt[i]; + } + + // return the hash of the result + const sharedKeyHash = new Uint8Array(Key_Size); + hashfunc(sharedKeyHash, sharedKey, Key_Size); + return sharedKeyHash; + }, + }; +})(); diff --git a/src/core/crypto/index.ts b/src/core/crypto/index.ts new file mode 100644 index 0000000000..1a168b4094 --- /dev/null +++ b/src/core/crypto/index.ts @@ -0,0 +1,18 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export * from './Crypto'; +export * from './KeyPair'; diff --git a/src/core/crypto/nacl_catapult.ts b/src/core/crypto/nacl_catapult.ts new file mode 100644 index 0000000000..1d47ac02fe --- /dev/null +++ b/src/core/crypto/nacl_catapult.ts @@ -0,0 +1,852 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// README: This is copied from tweeetnacl/nacl.fast.js and is updated to export custom hash functions. + +// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri. +// Public domain. +// +// Implementation derived from TweetNaCl version 20140427. +// See for details: http://tweetnacl.cr.yp.to/ +const _0 = new Uint8Array(16); +const _9 = new Uint8Array(32); +_9[0] = 9; + +export const gf = (init ? ) => { + // tslint:disable-next-line:one-variable-per-declaration + let i; + const r = new Float64Array(16); + if (init) { + for (i = 0; i < init.length; i++) { + r[i] = init[i]; + } + } + return r; +}; + +// tslint:disable-next-line:one-variable-per-declaration +const gf0 = gf(), + gf1 = gf([1]), + _121665 = gf([0xdb41, 1]), + D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, + 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203 + ]), + D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, + 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406 + ]), + X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, + 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169 + ]), + Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, + 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666 + ]), + I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, + 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83 + ]); +const L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, + 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10 +]); + +const A = (o, a, b) => { + for (let i = 0; i < 16; i++) { + o[i] = a[i] + b[i]; + } +}; + +const Z = (o, a, b) => { + for (let i = 0; i < 16; i++) { + o[i] = a[i] - b[i]; + } +}; + +const M = (o, a, b) => { + // tslint:disable-next-line:one-variable-per-declaration + let v, c, + t0 = 0, + t1 = 0, + t2 = 0, + t3 = 0, + t4 = 0, + t5 = 0, + t6 = 0, + t7 = 0, + t8 = 0, + t9 = 0, + t10 = 0, + t11 = 0, + t12 = 0, + t13 = 0, + t14 = 0, + t15 = 0, + t16 = 0, + t17 = 0, + t18 = 0, + t19 = 0, + t20 = 0, + t21 = 0, + t22 = 0, + t23 = 0, + t24 = 0, + t25 = 0, + t26 = 0, + t27 = 0, + t28 = 0, + t29 = 0, + t30 = 0, + b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3], + b4 = b[4], + b5 = b[5], + b6 = b[6], + b7 = b[7], + b8 = b[8], + b9 = b[9], + b10 = b[10], + b11 = b[11], + b12 = b[12], + b13 = b[13], + b14 = b[14], + b15 = b[15]; + + v = a[0]; + t0 += v * b0; + t1 += v * b1; + t2 += v * b2; + t3 += v * b3; + t4 += v * b4; + t5 += v * b5; + t6 += v * b6; + t7 += v * b7; + t8 += v * b8; + t9 += v * b9; + t10 += v * b10; + t11 += v * b11; + t12 += v * b12; + t13 += v * b13; + t14 += v * b14; + t15 += v * b15; + v = a[1]; + t1 += v * b0; + t2 += v * b1; + t3 += v * b2; + t4 += v * b3; + t5 += v * b4; + t6 += v * b5; + t7 += v * b6; + t8 += v * b7; + t9 += v * b8; + t10 += v * b9; + t11 += v * b10; + t12 += v * b11; + t13 += v * b12; + t14 += v * b13; + t15 += v * b14; + t16 += v * b15; + v = a[2]; + t2 += v * b0; + t3 += v * b1; + t4 += v * b2; + t5 += v * b3; + t6 += v * b4; + t7 += v * b5; + t8 += v * b6; + t9 += v * b7; + t10 += v * b8; + t11 += v * b9; + t12 += v * b10; + t13 += v * b11; + t14 += v * b12; + t15 += v * b13; + t16 += v * b14; + t17 += v * b15; + v = a[3]; + t3 += v * b0; + t4 += v * b1; + t5 += v * b2; + t6 += v * b3; + t7 += v * b4; + t8 += v * b5; + t9 += v * b6; + t10 += v * b7; + t11 += v * b8; + t12 += v * b9; + t13 += v * b10; + t14 += v * b11; + t15 += v * b12; + t16 += v * b13; + t17 += v * b14; + t18 += v * b15; + v = a[4]; + t4 += v * b0; + t5 += v * b1; + t6 += v * b2; + t7 += v * b3; + t8 += v * b4; + t9 += v * b5; + t10 += v * b6; + t11 += v * b7; + t12 += v * b8; + t13 += v * b9; + t14 += v * b10; + t15 += v * b11; + t16 += v * b12; + t17 += v * b13; + t18 += v * b14; + t19 += v * b15; + v = a[5]; + t5 += v * b0; + t6 += v * b1; + t7 += v * b2; + t8 += v * b3; + t9 += v * b4; + t10 += v * b5; + t11 += v * b6; + t12 += v * b7; + t13 += v * b8; + t14 += v * b9; + t15 += v * b10; + t16 += v * b11; + t17 += v * b12; + t18 += v * b13; + t19 += v * b14; + t20 += v * b15; + v = a[6]; + t6 += v * b0; + t7 += v * b1; + t8 += v * b2; + t9 += v * b3; + t10 += v * b4; + t11 += v * b5; + t12 += v * b6; + t13 += v * b7; + t14 += v * b8; + t15 += v * b9; + t16 += v * b10; + t17 += v * b11; + t18 += v * b12; + t19 += v * b13; + t20 += v * b14; + t21 += v * b15; + v = a[7]; + t7 += v * b0; + t8 += v * b1; + t9 += v * b2; + t10 += v * b3; + t11 += v * b4; + t12 += v * b5; + t13 += v * b6; + t14 += v * b7; + t15 += v * b8; + t16 += v * b9; + t17 += v * b10; + t18 += v * b11; + t19 += v * b12; + t20 += v * b13; + t21 += v * b14; + t22 += v * b15; + v = a[8]; + t8 += v * b0; + t9 += v * b1; + t10 += v * b2; + t11 += v * b3; + t12 += v * b4; + t13 += v * b5; + t14 += v * b6; + t15 += v * b7; + t16 += v * b8; + t17 += v * b9; + t18 += v * b10; + t19 += v * b11; + t20 += v * b12; + t21 += v * b13; + t22 += v * b14; + t23 += v * b15; + v = a[9]; + t9 += v * b0; + t10 += v * b1; + t11 += v * b2; + t12 += v * b3; + t13 += v * b4; + t14 += v * b5; + t15 += v * b6; + t16 += v * b7; + t17 += v * b8; + t18 += v * b9; + t19 += v * b10; + t20 += v * b11; + t21 += v * b12; + t22 += v * b13; + t23 += v * b14; + t24 += v * b15; + v = a[10]; + t10 += v * b0; + t11 += v * b1; + t12 += v * b2; + t13 += v * b3; + t14 += v * b4; + t15 += v * b5; + t16 += v * b6; + t17 += v * b7; + t18 += v * b8; + t19 += v * b9; + t20 += v * b10; + t21 += v * b11; + t22 += v * b12; + t23 += v * b13; + t24 += v * b14; + t25 += v * b15; + v = a[11]; + t11 += v * b0; + t12 += v * b1; + t13 += v * b2; + t14 += v * b3; + t15 += v * b4; + t16 += v * b5; + t17 += v * b6; + t18 += v * b7; + t19 += v * b8; + t20 += v * b9; + t21 += v * b10; + t22 += v * b11; + t23 += v * b12; + t24 += v * b13; + t25 += v * b14; + t26 += v * b15; + v = a[12]; + t12 += v * b0; + t13 += v * b1; + t14 += v * b2; + t15 += v * b3; + t16 += v * b4; + t17 += v * b5; + t18 += v * b6; + t19 += v * b7; + t20 += v * b8; + t21 += v * b9; + t22 += v * b10; + t23 += v * b11; + t24 += v * b12; + t25 += v * b13; + t26 += v * b14; + t27 += v * b15; + v = a[13]; + t13 += v * b0; + t14 += v * b1; + t15 += v * b2; + t16 += v * b3; + t17 += v * b4; + t18 += v * b5; + t19 += v * b6; + t20 += v * b7; + t21 += v * b8; + t22 += v * b9; + t23 += v * b10; + t24 += v * b11; + t25 += v * b12; + t26 += v * b13; + t27 += v * b14; + t28 += v * b15; + v = a[14]; + t14 += v * b0; + t15 += v * b1; + t16 += v * b2; + t17 += v * b3; + t18 += v * b4; + t19 += v * b5; + t20 += v * b6; + t21 += v * b7; + t22 += v * b8; + t23 += v * b9; + t24 += v * b10; + t25 += v * b11; + t26 += v * b12; + t27 += v * b13; + t28 += v * b14; + t29 += v * b15; + v = a[15]; + t15 += v * b0; + t16 += v * b1; + t17 += v * b2; + t18 += v * b3; + t19 += v * b4; + t20 += v * b5; + t21 += v * b6; + t22 += v * b7; + t23 += v * b8; + t24 += v * b9; + t25 += v * b10; + t26 += v * b11; + t27 += v * b12; + t28 += v * b13; + t29 += v * b14; + t30 += v * b15; + + t0 += 38 * t16; + t1 += 38 * t17; + t2 += 38 * t18; + t3 += 38 * t19; + t4 += 38 * t20; + t5 += 38 * t21; + t6 += 38 * t22; + t7 += 38 * t23; + t8 += 38 * t24; + t9 += 38 * t25; + t10 += 38 * t26; + t11 += 38 * t27; + t12 += 38 * t28; + t13 += 38 * t29; + t14 += 38 * t30; + // t15 left as is + + // first car + c = 1; + v = t0 + c + 65535; + c = Math.floor(v / 65536); + t0 = v - c * 65536; + v = t1 + c + 65535; + c = Math.floor(v / 65536); + t1 = v - c * 65536; + v = t2 + c + 65535; + c = Math.floor(v / 65536); + t2 = v - c * 65536; + v = t3 + c + 65535; + c = Math.floor(v / 65536); + t3 = v - c * 65536; + v = t4 + c + 65535; + c = Math.floor(v / 65536); + t4 = v - c * 65536; + v = t5 + c + 65535; + c = Math.floor(v / 65536); + t5 = v - c * 65536; + v = t6 + c + 65535; + c = Math.floor(v / 65536); + t6 = v - c * 65536; + v = t7 + c + 65535; + c = Math.floor(v / 65536); + t7 = v - c * 65536; + v = t8 + c + 65535; + c = Math.floor(v / 65536); + t8 = v - c * 65536; + v = t9 + c + 65535; + c = Math.floor(v / 65536); + t9 = v - c * 65536; + v = t10 + c + 65535; + c = Math.floor(v / 65536); + t10 = v - c * 65536; + v = t11 + c + 65535; + c = Math.floor(v / 65536); + t11 = v - c * 65536; + v = t12 + c + 65535; + c = Math.floor(v / 65536); + t12 = v - c * 65536; + v = t13 + c + 65535; + c = Math.floor(v / 65536); + t13 = v - c * 65536; + v = t14 + c + 65535; + c = Math.floor(v / 65536); + t14 = v - c * 65536; + v = t15 + c + 65535; + c = Math.floor(v / 65536); + t15 = v - c * 65536; + t0 += c - 1 + 37 * (c - 1); + + // second car + c = 1; + v = t0 + c + 65535; + c = Math.floor(v / 65536); + t0 = v - c * 65536; + v = t1 + c + 65535; + c = Math.floor(v / 65536); + t1 = v - c * 65536; + v = t2 + c + 65535; + c = Math.floor(v / 65536); + t2 = v - c * 65536; + v = t3 + c + 65535; + c = Math.floor(v / 65536); + t3 = v - c * 65536; + v = t4 + c + 65535; + c = Math.floor(v / 65536); + t4 = v - c * 65536; + v = t5 + c + 65535; + c = Math.floor(v / 65536); + t5 = v - c * 65536; + v = t6 + c + 65535; + c = Math.floor(v / 65536); + t6 = v - c * 65536; + v = t7 + c + 65535; + c = Math.floor(v / 65536); + t7 = v - c * 65536; + v = t8 + c + 65535; + c = Math.floor(v / 65536); + t8 = v - c * 65536; + v = t9 + c + 65535; + c = Math.floor(v / 65536); + t9 = v - c * 65536; + v = t10 + c + 65535; + c = Math.floor(v / 65536); + t10 = v - c * 65536; + v = t11 + c + 65535; + c = Math.floor(v / 65536); + t11 = v - c * 65536; + v = t12 + c + 65535; + c = Math.floor(v / 65536); + t12 = v - c * 65536; + v = t13 + c + 65535; + c = Math.floor(v / 65536); + t13 = v - c * 65536; + v = t14 + c + 65535; + c = Math.floor(v / 65536); + t14 = v - c * 65536; + v = t15 + c + 65535; + c = Math.floor(v / 65536); + t15 = v - c * 65536; + t0 += c - 1 + 37 * (c - 1); + + o[0] = t0; + o[1] = t1; + o[2] = t2; + o[3] = t3; + o[4] = t4; + o[5] = t5; + o[6] = t6; + o[7] = t7; + o[8] = t8; + o[9] = t9; + o[10] = t10; + o[11] = t11; + o[12] = t12; + o[13] = t13; + o[14] = t14; + o[15] = t15; +}; + +const S = (o, a) => { + M(o, a, a); +}; +const vn = (x, xi, y, yi, n) => { + // tslint:disable-next-line:one-variable-per-declaration + let i, d = 0; + for (i = 0; i < n; i++) { + d |= x[xi + i] ^ y[yi + i]; + } + return (1 & ((d - 1) >>> 8)) - 1; +}; + +const pow2523 = (o, i) => { + const c = gf(); + let a; + for (a = 0; a < 16; a++) { + c[a] = i[a]; + } + for (a = 250; a >= 0; a--) { + S(c, c); + if (a !== 1) { + M(c, c, i); + } + } + for (a = 0; a < 16; a++) { + o[a] = c[a]; + } +}; +const inv25519 = (o, i) => { + const c = gf(); + let a; + for (a = 0; a < 16; a++) { + c[a] = i[a]; + } + for (a = 253; a >= 0; a--) { + S(c, c); + if (a !== 2 && a !== 4) { + M(c, c, i); + } + } + for (a = 0; a < 16; a++) { + o[a] = c[a]; + } +}; +const set25519 = (r, a) => { + let i; + for (i = 0; i < 16; i++) { + r[i] = a[i] | 0; + } +}; + +const car25519 = (o) => { + // tslint:disable-next-line:one-variable-per-declaration + let i, v, c = 1; + for (i = 0; i < 16; i++) { + v = o[i] + c + 65535; + c = Math.floor(v / 65536); + o[i] = v - c * 65536; + } + o[0] += c - 1 + 37 * (c - 1); +}; + +const sel25519 = (p, q, b) => { + // tslint:disable-next-line:one-variable-per-declaration + let t, c = ~(b - 1); + for (let i = 0; i < 16; i++) { + t = c & (p[i] ^ q[i]); + p[i] ^= t; + q[i] ^= t; + } +}; + +const pack25519 = (o, n) => { + // tslint:disable-next-line:one-variable-per-declaration + let i, j, b; + // tslint:disable-next-line:one-variable-per-declaration + const m = gf(), + t = gf(); + for (i = 0; i < 16; i++) { + t[i] = n[i]; + } + car25519(t); + car25519(t); + car25519(t); + for (j = 0; j < 2; j++) { + m[0] = t[0] - 0xffed; + for (i = 1; i < 15; i++) { + m[i] = t[i] - 0xffff - ((m[i - 1] >> 16) & 1); + m[i - 1] &= 0xffff; + } + m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1); + b = (m[15] >> 16) & 1; + m[14] &= 0xffff; + sel25519(t, m, 1 - b); + } + for (i = 0; i < 16; i++) { + o[2 * i] = t[i] & 0xff; + o[2 * i + 1] = t[i] >> 8; + } +}; + +const cswap = (p, q, b) => { + let i; + for (i = 0; i < 4; i++) { + sel25519(p[i], q[i], b); + } +}; + +const neq25519 = (a, b) => { + // tslint:disable-next-line:one-variable-per-declaration + const c = new Uint8Array(32), + d = new Uint8Array(32); + pack25519(c, a); + pack25519(d, b); + return crypto_verify_32(c, 0, d, 0); +}; + +const par25519 = (a) => { + const d = new Uint8Array(32); + pack25519(d, a); + return d[0] & 1; +}; + +const unpack25519 = (o, n) => { + let i; + for (i = 0; i < 16; i++) { + o[i] = n[2 * i] + (n[2 * i + 1] << 8); + } + o[15] &= 0x7fff; +}; + +export const cleanup = (arr) => { + for (var i = 0; i < arr.length; i++) { + arr[i] = 0; + } +}; + +export const crypto_shared_key_hash = (shared, pk, sk, hashfunc) => { + const d = new Uint8Array(64); + const p = [gf(), gf(), gf(), gf()]; + + hashfunc(d, sk, 32); + d[0] &= 248; + d[31] &= 127; + d[31] |= 64; + + let q = [gf(), gf(), gf(), gf()]; + unpackneg(q, pk); + scalarmult(p, q, d); + pack(shared, p); +}; + +export const crypto_verify_32 = (x, xi, y, yi) => { + return vn(x, xi, y, yi, 32); +}; + +export const add = (p, q) => { + // tslint:disable-next-line:one-variable-per-declaration + const a = gf(), + b = gf(), + c = gf(), + d = gf(), + e = gf(), + f = gf(), + g = gf(), + h = gf(), + t = gf(); + + Z(a, p[1], p[0]); + Z(t, q[1], q[0]); + M(a, a, t); + A(b, p[0], p[1]); + A(t, q[0], q[1]); + M(b, b, t); + M(c, p[3], q[3]); + M(c, c, D2); + M(d, p[2], q[2]); + A(d, d, d); + Z(e, b, a); + Z(f, d, c); + A(g, d, c); + A(h, b, a); + + M(p[0], e, f); + M(p[1], h, g); + M(p[2], g, f); + M(p[3], e, h); +}; + +export const modL = (r, x) => { + // tslint:disable-next-line:one-variable-per-declaration + let carry, i, j, k; + for (i = 63; i >= 32; --i) { + carry = 0; + for (j = i - 32, k = i - 12; j < k; ++j) { + x[j] += carry - 16 * x[i] * L[j - (i - 32)]; + carry = (x[j] + 128) >> 8; + x[j] -= carry * 256; + } + x[j] += carry; + x[i] = 0; + } + carry = 0; + for (j = 0; j < 32; j++) { + x[j] += carry - (x[31] >> 4) * L[j]; + carry = x[j] >> 8; + x[j] &= 255; + } + for (j = 0; j < 32; j++) { + x[j] -= carry * L[j]; + } + for (i = 0; i < 32; i++) { + x[i + 1] += x[i] >> 8; + r[i] = x[i] & 255; + } +}; + +export const reduce = (r) => { + // tslint:disable-next-line:one-variable-per-declaration + let x = new Float64Array(64), + i; + for (i = 0; i < 64; i++) { + x[i] = r[i]; + } + for (i = 0; i < 64; i++) { + r[i] = 0; + } + modL(r, x); +}; + +export const pack = (r, p) => { + // tslint:disable-next-line:one-variable-per-declaration + const tx = gf(), + ty = gf(), + zi = gf(); + inv25519(zi, p[2]); + M(tx, p[0], zi); + M(ty, p[1], zi); + pack25519(r, ty); + r[31] ^= par25519(tx) << 7; +}; + +export const scalarmult = (p, q, s) => { + // tslint:disable-next-line:one-variable-per-declaration + let b, i; + set25519(p[0], gf0); + set25519(p[1], gf1); + set25519(p[2], gf1); + set25519(p[3], gf0); + for (i = 255; i >= 0; --i) { + b = (s[(i / 8) | 0] >> (i & 7)) & 1; + cswap(p, q, b); + add(q, p); + add(p, p); + cswap(p, q, b); + } +}; + +export const scalarbase = (p, s) => { + const q = [gf(), gf(), gf(), gf()]; + set25519(q[0], X); + set25519(q[1], Y); + set25519(q[2], gf1); + M(q[3], X, Y); + scalarmult(p, q, s); +}; + +export const unpackneg = (r, p) => { + // tslint:disable-next-line:one-variable-per-declaration + const t = gf(), + chk = gf(), + num = gf(), + den = gf(), + den2 = gf(), + den4 = gf(), + den6 = gf(); + + set25519(r[2], gf1); + unpack25519(r[1], p); + S(num, r[1]); + M(den, num, D); + Z(num, num, r[2]); + A(den, r[2], den); + + S(den2, den); + S(den4, den2); + M(den6, den4, den2); + M(t, den6, num); + M(t, t, den); + + pow2523(t, t); + M(t, t, num); + M(t, t, den); + M(t, t, den); + M(r[0], t, den); + + S(chk, r[0]); + M(chk, chk, den); + if (neq25519(chk, num)) { + M(r[0], r[0], I); + } + + S(chk, r[0]); + M(chk, chk, den); + if (neq25519(chk, num)) { + return -1; + } + + if (par25519(r[0]) === (p[31] >> 7)) { + Z(r[0], gf0, r[0]); + } + + M(r[3], r[0], r[1]); + return 0; +}; diff --git a/src/model/account/Account.ts b/src/model/account/Account.ts index e94f7ec420..53acfdfc4e 100644 --- a/src/model/account/Account.ts +++ b/src/model/account/Account.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import {KeyPair, nacl_catapult} from 'nem2-library'; +import {Crypto, KeyPair} from '../../core/crypto'; import {Convert as convert, RawAddress as AddressLibrary} from '../../core/format'; import {NetworkType} from '../blockchain/NetworkType'; import {AggregateTransaction} from '../transaction/AggregateTransaction'; @@ -71,7 +71,7 @@ export class Account { public static generateNewAccount(networkType: NetworkType): Account { // Create random bytes - const randomBytesArray = nacl_catapult.randomBytes(32); + const randomBytesArray = Crypto.randomBytes(32); // Hash random bytes with entropy seed // Finalize and keep only 32 bytes const hashKey = convert.uint8ToHex(randomBytesArray); // TODO: derive private key correctly diff --git a/src/model/account/PublicAccount.ts b/src/model/account/PublicAccount.ts index 06b169e58e..84c2b2ea3c 100644 --- a/src/model/account/PublicAccount.ts +++ b/src/model/account/PublicAccount.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import { KeyPair } from 'nem2-library'; +import { KeyPair } from '../../core/crypto'; import { Convert as convert} from '../../core/format'; import { NetworkType } from '../blockchain/NetworkType'; import { Address } from './Address'; diff --git a/src/model/model.ts b/src/model/model.ts index c4d31efe5b..383305be0d 100644 --- a/src/model/model.ts +++ b/src/model/model.ts @@ -131,3 +131,4 @@ export * from './wallet/EncryptedPrivateKey'; export * from './wallet/Password'; export * from './wallet/SimpleWallet'; export * from './wallet/Wallet'; +export * from './wallet/WalletAlgorithm'; diff --git a/src/model/mosaic/MosaicNonce.ts b/src/model/mosaic/MosaicNonce.ts index 00985bd81a..2ef1dfe28f 100644 --- a/src/model/mosaic/MosaicNonce.ts +++ b/src/model/mosaic/MosaicNonce.ts @@ -13,9 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import { - nacl_catapult, -} from 'nem2-library'; +import {Crypto} from '../../core/crypto'; import { Convert as convert} from '../../core/format'; /** * The mosaic nonce structure @@ -35,7 +33,7 @@ export class MosaicNonce { * @return {MosaicNonce} */ public static createRandom(): MosaicNonce { - const bytes = nacl_catapult.randomBytes(4); + const bytes = Crypto.randomBytes(4); const nonce = new Uint8Array(bytes); return new MosaicNonce(nonce); } diff --git a/src/model/transaction/EncryptedMessage.ts b/src/model/transaction/EncryptedMessage.ts index 170378174b..de23a5516d 100644 --- a/src/model/transaction/EncryptedMessage.ts +++ b/src/model/transaction/EncryptedMessage.ts @@ -14,7 +14,7 @@ * limitations under the License. */ -import {crypto} from 'nem2-library'; +import {Crypto} from '../../core/crypto'; import {PublicAccount} from '../account/PublicAccount'; import {Message} from './Message'; import {MessageType} from './MessageType'; @@ -41,7 +41,7 @@ export class EncryptedMessage extends Message { */ public static create(message: string, recipientPublicAccount: PublicAccount, privateKey) { return new EncryptedMessage( - crypto.encode(privateKey, recipientPublicAccount.publicKey, message).toUpperCase(), + Crypto.encode(privateKey, recipientPublicAccount.publicKey, message).toUpperCase(), recipientPublicAccount); } @@ -60,6 +60,6 @@ export class EncryptedMessage extends Message { * @param recipientPublicAccount - Sender public account */ public static decrypt(encryptMessage: EncryptedMessage, privateKey, recipientPublicAccount: PublicAccount): PlainMessage { - return new PlainMessage(this.decodeHex(crypto.decode(privateKey, recipientPublicAccount.publicKey, encryptMessage.payload))); + return new PlainMessage(this.decodeHex(Crypto.decode(privateKey, recipientPublicAccount.publicKey, encryptMessage.payload))); } } diff --git a/src/model/wallet/EncryptedPrivateKey.ts b/src/model/wallet/EncryptedPrivateKey.ts index b6172679ee..ff6f21132b 100644 --- a/src/model/wallet/EncryptedPrivateKey.ts +++ b/src/model/wallet/EncryptedPrivateKey.ts @@ -14,8 +14,9 @@ * limitations under the License. */ -import {crypto} from 'nem2-library'; +import {Crypto} from '../../core/crypto'; import {Password} from './Password'; +import { WalletAlgorithm } from './WalletAlgorithm'; /** * EncryptedPrivateKey model @@ -52,7 +53,7 @@ export class EncryptedPrivateKey { encrypted: this.encryptedKey, iv: this.iv, }; - crypto.passwordToPrivatekey(common, wallet, 'pass:bip32'); + Crypto.passwordToPrivateKey(common, wallet, WalletAlgorithm.Pass_bip32); return common.privateKey; } } diff --git a/src/model/wallet/SimpleWallet.ts b/src/model/wallet/SimpleWallet.ts index 2797c6a3cb..f1ce97225d 100644 --- a/src/model/wallet/SimpleWallet.ts +++ b/src/model/wallet/SimpleWallet.ts @@ -15,7 +15,7 @@ */ import {LocalDateTime} from 'js-joda'; -import {crypto, KeyPair, nacl_catapult} from 'nem2-library'; +import {Crypto, KeyPair} from '../../core/crypto'; import { Convert as convert} from '../../core/format'; import {Account} from '../account/Account'; import {Address} from '../account/Address'; @@ -57,7 +57,7 @@ export class SimpleWallet extends Wallet { */ public static create(name: string, password: Password, network: NetworkType): SimpleWallet { // Create random bytes - const randomBytesArray = nacl_catapult.randomBytes(32); + const randomBytesArray = Crypto.randomBytes(32); // Hash random bytes with entropy seed // Finalize and keep only 32 bytes const hashKey = convert.uint8ToHex(randomBytesArray); // TODO: derive private key correctly @@ -69,7 +69,7 @@ export class SimpleWallet extends Wallet { const address = Address.createFromPublicKey(convert.uint8ToHex(keyPair.publicKey), network); // Encrypt private key using password - const encrypted = crypto.encodePrivKey(hashKey, password.value); + const encrypted = Crypto.encodePrivateKey(hashKey, password.value); const encryptedPrivateKey = new EncryptedPrivateKey(encrypted.ciphertext, encrypted.iv); @@ -92,7 +92,7 @@ export class SimpleWallet extends Wallet { const address = Address.createFromPublicKey(convert.uint8ToHex(keyPair.publicKey), network); // Encrypt private key using password - const encrypted = crypto.encodePrivKey(privateKey, password.value); + const encrypted = Crypto.encodePrivateKey(privateKey, password.value); const encryptedPrivateKey = new EncryptedPrivateKey(encrypted.ciphertext, encrypted.iv); diff --git a/src/model/wallet/WalletAlgorithm.ts b/src/model/wallet/WalletAlgorithm.ts new file mode 100644 index 0000000000..fd7bec5a2e --- /dev/null +++ b/src/model/wallet/WalletAlgorithm.ts @@ -0,0 +1,22 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export enum WalletAlgorithm { + Pass_6k = 1, + Pass_bip32 = 2, + Pass_enc = 4, + Trezor = 3, +} From 7daa764232decc90e8c6c9570cd10f65aa213a2e Mon Sep 17 00:00:00 2001 From: Steven Liu Date: Wed, 12 Jun 2019 09:14:08 +0100 Subject: [PATCH 6/7] Added unit test --- test/core/crypto/crypto.spec.ts | 481 ++++++++++++++++++++++++++++ test/core/crypto/keyPair.spec.ts | 420 ++++++++++++++++++++++++ test/core/crypto/sha3Hasher.spec.ts | 150 +++++++++ 3 files changed, 1051 insertions(+) create mode 100644 test/core/crypto/crypto.spec.ts create mode 100644 test/core/crypto/keyPair.spec.ts create mode 100644 test/core/crypto/sha3Hasher.spec.ts diff --git a/test/core/crypto/crypto.spec.ts b/test/core/crypto/crypto.spec.ts new file mode 100644 index 0000000000..f022085c48 --- /dev/null +++ b/test/core/crypto/crypto.spec.ts @@ -0,0 +1,481 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {Crypto} from '../../../src/core/crypto'; +import {Convert as convert} from '../../../src/core/format'; +import { WalletAlgorithm } from '../../../src/model/model'; + +const CryptoJS = require('crypto-js'); +describe('crypto tests', () => { + it('Can derive a key from password and count', () => { + // Arrange: + const password = 'TestTest'; + const count = 20; + const expectedKey = '8cd87bc513857a7079d182a6e19b370e907107d97bd3f81a85bcebcc4b5bd3b5'; + + // Act: + const result = Crypto.derivePassSha(password, count); + + // Assert: + expect(result.priv).equal(expectedKey); + }); + + it('Can encrypt a private key', () => { + // Arrange: + const password = 'TestTest'; + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const expectedKey = '8cd87bc513857a7079d182a6e19b370e907107d97bd3f81a85bcebcc4b5bd3b5'; + + // Act: + const result = Crypto.encodePrivateKey(privateKey, password); + const pass = Crypto.derivePassSha(password, 20); + + // Assert: + expect(pass.priv).equal(expectedKey); + expect(result.iv.length).equal(16 * 2); + expect(result.ciphertext.length).equal(48 * 2); + }); + + it('Can decrypt a private key', () => { + // Arrange: + const expectedPrivateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const key = '8cd87bc513857a7079d182a6e19b370e907107d97bd3f81a85bcebcc4b5bd3b5'; + const encrypted = 'c09ef3ed0cadd6ca6d3638b5dd854ac871a0afaec6b7fed791166b571a64d57f564376dc0180c851b0a1120b5896e6a0'; + const iv = '0329814121c7a4bb11418084dbe40560'; + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(encrypted), + iv: convert.hexToUint8(iv), + key: convert.hexToUint8(key), + }; + + // Act: + const decrypted = Crypto.decrypt(obj); + + // Assert: + expect(decrypted).equal(expectedPrivateKey); + }); + + it('Can encrypt and decrypt private Key', () => { + // Arrange: + const password = 'TestTest'; + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.encodePrivateKey(privateKey, password); + const pass = Crypto.derivePassSha(password, 20); + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(result.ciphertext), + iv: convert.hexToUint8(result.iv), + key: convert.hexToUint8(pass.priv), + }; + const decrypted = Crypto.decrypt(obj); + + // Assert: + expect(privateKey).equal(decrypted); + }); + + describe('Encrypt private key edge-cases', () => { + it('Encryption throw error if no password', () => { + // Arrange: + const password = ''; + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.encodePrivateKey.bind(null, privateKey, password); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Encryption throw error if no private key', () => { + // Arrange: + const password = 'TestTest'; + const privateKey = ''; + + // Act + const result = Crypto.encodePrivateKey.bind(null, privateKey, password); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + }); + + it('Can decrypt private key of pass:enc wallets', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_enc; + const expectedPrivateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Can decrypt private key of pass:bip32 wallets', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_bip32; + const expectedPrivateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Can decrypt private key of pass:6k wallets', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '', + iv: '', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + const expectedPrivateKey = '8fac70ea9aca3ae3418e25c0d31d9a0723e0a1790ae8fa97747c00dc0037472e'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Can decrypt private key of pass:6k wallets childs', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '5c3a7ebbefb391e5175a29ec5a22cb162cd590bb2e0b09416273f86bdc39fa83c04c4bb53b9c64fd1e6eaba5dba149bd', + iv: 'f131d9a4dfb1b0b696e05ccae9412e8f', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + const expectedPrivateKey = '4f27ca43521bbc394a6f6dde65b533e0768f954fa47ce320b0e9f4b5fe450f9d'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + describe('Decrypt private key edge-cases', () => { + it('Private key decryption throw error if no algo', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = ''; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:enc wallets thow error if no password', () => { + // Arrange: + const common = { + password: '', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_enc; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:bip32 wallets throw error if no password', () => { + // Arrange: + const common = { + password: '', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_bip32; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:6k wallets throw error if no password', () => { + // Arrange: + const common = { + password: '', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + + // Act: + const result = Crypto.passwordToPrivateKey.bind(null, common, walletAccount, mainAlgo); + + // Assert: + expect(result).to.throw('Missing argument !'); + }); + + it('Decryption of pass:6k wallets generate a private key if no encrypted and iv in wallet account', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '', + iv: '', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + const expectedPrivateKey = '8fac70ea9aca3ae3418e25c0d31d9a0723e0a1790ae8fa97747c00dc0037472e'; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(true); + expect(common.privateKey).equal(expectedPrivateKey); + }); + + it('Decryption of pass:6k wallets return false if encrypted data but no iv', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '2e1717f245b7e1138b0dfe99dfce65b16b1c9d8ca03a9f90b86b43677b6337ce56ec474c64f73244790eb2490ad14752', + iv: '', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(false); + expect(common.privateKey).equal(''); + }); + + it('Decryption of pass:6k wallets return false if no encrypted data but iv', () => { + // Arrange: + const common = { + password: 'TestTest', + privateKey: '', + }; + const walletAccount = { + encrypted: '', + iv: 'dccffaa4883cda85d6b06714aabe6ec6', + }; + const mainAlgo = WalletAlgorithm.Pass_6k; + + // Act: + const result = Crypto.passwordToPrivateKey(common, walletAccount, mainAlgo); + + // Assert: + expect(result).equal(false); + expect(common.privateKey).equal(''); + }); + }); + + it('Can encode and decode message', () => { + const senderPriv = 'E1C8521608F4896CA26A0C2DE739310EA4B06861D126CF4D6922064678A1969B'; + const recipientPublic = '12AAD2D33020C3EAE12592875CD7D2FF54A61DD03C1FAADB84A083D41F75C229'; + const message = 'NEM is awesome !'; + const encryptedMessage = Crypto.encode(senderPriv, recipientPublic, message); + const senderPublic = '9F784BF20318AE3CA6246C0EC2207FE095FFF7A84B6787E7E3C2CE4C3B92A2EA'; + const recipientPriv = 'A22A4BBF126A2D7D7ECE823174DFD184C5DE0FDE4CB2075D30CFA409F7EF8908'; + const expectedMessage = 'NEM is awesome !'; + const decrypted = Crypto.decode(recipientPriv, senderPublic, encryptedMessage); + + expect(decrypted).equal(convert.utf8ToHex(expectedMessage)); + }); + + it('Can encode a message and failed decode with wrong key', () => { + const senderPriv = 'E1C8521608F4896CA26A0C2DE739310EA4B06861D126CF4D6922064678A1969B'; + const recipientPublic = '12AAD2D33020C3EAE12592875CD7D2FF54A61DD03C1FAADB84A083D41F75C229'; + const message = 'NEM is awesome !'; + const encryptedMessage = Crypto.encode(senderPriv, recipientPublic, message); + const senderPublic = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6'; + const recipientPriv = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6'; + const expectedMessage = 'NEM is awesome !'; + const decrypted = Crypto.decode(recipientPriv, senderPublic, encryptedMessage); + + expect(decrypted).not.equal(convert.utf8ToHex(expectedMessage)); + }); + + describe('Encode & decode message edge-cases', () => { + it('Message encoding throw error if no sender private key', () => { + // Arrange: + const senderPriv = ''; + const recipientPublic = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = 'NEM is awesome !'; + + // Act: + const result = Crypto.encode.bind(null, senderPriv, recipientPublic, message); + + // Assert: + expect(result).to.throw(); + }); + + it('Message encoding throw error if no recipient public key', () => { + // Arrange: + const senderPriv = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const recipientPublic = ''; + const message = 'NEM is awesome !'; + + // Act: + const result = Crypto.encode.bind(null, senderPriv, recipientPublic, message); + + // Assert: + expect(result).to.throw(); + }); + + it('Message encoding throw error if no message', () => { + // Arrange: + const senderPriv = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const recipientPublic = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = ''; + + // Act: + const result = Crypto.encode.bind(null, senderPriv, recipientPublic, message); + + // Assert: + expect(result).to.throw(); + }); + + it('Message decoding throw error if no recipient private key', () => { + // Arrange: + const senderPublic = '9291abb3c52134be9d20ef21a796743497df7776d2661237bda9cadade34e44c'; + const recipientPriv = ''; + const message = 'NEM is awesome !'; + const encryptedMessage = 'dd31d6b4111c1023bae6533399e74f73a29c6e6b48ab550f8a7bea127e27ddd' + + 'b4fd3fe4fad3c835307c0da52d9c268f56237d1810e07912e6a6568cba09d9a9176ee6b1ade9569c2e1e273e9675bd4ff'; + + // Act: + const result = Crypto.decode.bind(null, recipientPriv, senderPublic, encryptedMessage); + + // Assert: + expect(result).to.throw(); + }); + + it('Message decoding throw error if no sender public key', () => { + // Arrange: + const senderPublic = ''; + const recipientPriv = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = 'NEM is awesome !'; + const encryptedMessage = 'dd31d6b4111c1023bae6533399e74f73a29c6e6b48ab550f8a7bea127e27ddd' + + 'b4fd3fe4fad3c835307c0da52d9c268f56237d1810e07912e6a6568cba09d9a9176ee6b1ade9569c2e1e273e9675bd4ff'; + + // Act: + const result = Crypto.decode.bind(null, recipientPriv, senderPublic, encryptedMessage); + + // Assert: + expect(result).to.throw(); + }); + + it('Message decoding throw error if no payload', () => { + // Arrange: + const senderPublic = '9291abb3c52134be9d20ef21a796743497df7776d2661237bda9cadade34e44c'; + const recipientPriv = '2618090794e9c9682f2ac6504369a2f4fb9fe7ee7746f9560aca228d355b1cb9'; + const message = 'NEM is awesome !'; + const encryptedMessage = ''; + + // Act: + const result = Crypto.decode.bind(null, recipientPriv, senderPublic, encryptedMessage); + + // Assert: + expect(result).to.throw(); + }); + }); + + it('Can encrypt and decrypt private key for mobile', () => { + // Arrange: + const privateKey = '2a91e1d5c110a8d0105aad4683f962c2a56663a3cad46666b16d243174673d90'; + const password = 'TestTest'; + + // Act: + const result = Crypto.toMobileKey(password, privateKey); + const encrypted = result.encrypted; + const salt = CryptoJS.enc.Hex.parse(result.salt); + + const key = CryptoJS.PBKDF2(password, salt, { + keySize: 256 / 32, + iterations: 2000, + }); + + const iv = encrypted.substring(0, 32); + const encryptedPrvKey = encrypted.substring(32, 128); + + const obj = { + ciphertext: CryptoJS.enc.Hex.parse(encryptedPrvKey), + iv: convert.hexToUint8(iv), + key: convert.hexToUint8(key.toString()), + }; + + const decrypted = Crypto.decrypt(obj); + + // Assert: + expect(encrypted.length).equal(128); + expect(salt.toString().length).equal(32 * 2); + expect(decrypted).equal(privateKey); + }); +}); diff --git a/test/core/crypto/keyPair.spec.ts b/test/core/crypto/keyPair.spec.ts new file mode 100644 index 0000000000..8f4d9af157 --- /dev/null +++ b/test/core/crypto/keyPair.spec.ts @@ -0,0 +1,420 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {Crypto, KeyPair} from '../../../src/core/crypto'; +import {Convert as convert} from '../../../src/core/format'; + +describe('key pair', () => { + const randomKeyPair = () => KeyPair.createKeyPairFromPrivateKeyString(convert.uint8ToHex(Crypto.randomBytes(32))); + const Private_Key_Size = 32; + const Signature_Size = 64; + + const Private_Keys = [ + '8D31B712AB28D49591EAF5066E9E967B44507FC19C3D54D742F7B3A255CFF4AB', + '15923F9D2FFFB11D771818E1F7D7DDCD363913933264D58533CB3A5DD2DAA66A', + 'A9323CEF24497AB770516EA572A0A2645EE2D5A75BC72E78DE534C0A03BC328E', + 'D7D816DA0566878EE739EDE2131CD64201BCCC27F88FA51BA5815BCB0FE33CC8', + '27FC9998454848B987FAD89296558A34DEED4358D1517B953572F3E0AAA0A22D', + ]; + + describe('construction', () => { + it('can extract from private key test vectors', () => { + // Arrange: + const Expected_Public_Keys = [ + '53C659B47C176A70EB228DE5C0A0FF391282C96640C2A42CD5BBD0982176AB1B', + '3FE4A1AA148F5E76891CE924F5DC05627A87047B2B4AD9242C09C0ECED9B2338', + 'F398C0A2BDACDBD7037D2F686727201641BBF87EF458F632AE2A04B4E8F57994', + '6A283A241A8D8203B3A1E918B1E6F0A3E14E75E16D4CFFA45AE4EF89E38ED6B5', + '4DC62B38215826438DE2369743C6BBE6D13428405025DFEFF2857B9A9BC9D821', + ]; + + // Sanity: + expect(Private_Keys.length).equal(Expected_Public_Keys.length); + + for (let i = 0; i < Private_Keys.length; ++i) { + // Arrange: + const privateKeyHex = Private_Keys[i]; + const expectedPublicKey = Expected_Public_Keys[i]; + + // Act: + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(privateKeyHex); + + // Assert: + const message = ` from ${privateKeyHex}`; + expect(convert.uint8ToHex(keyPair.publicKey), `public ${message}`).equal(expectedPublicKey); + expect(convert.uint8ToHex(keyPair.privateKey), `private ${message}`).equal(privateKeyHex); + } + }); + + it('cannot extract from invalid private key', () => { + // Arrange: + const invalidPrivateKeys = [ + '', // empty + '53C659B47C176A70EB228DE5C0A0FF391282C96640C2A42CD5BBD0982176AB', // short + '53C659B47C176A70EB228DE5C0A0FF391282C96640C2A42CD5BBD0982176AB1BBB', // long + ]; + + // Act: + invalidPrivateKeys.forEach((privateKey) => { + // Assert: + expect(() => { + KeyPair.createKeyPairFromPrivateKeyString(privateKey); + }, `from ${privateKey}`) + .to.throw('private key has unexpected size'); + }); + }); + }); + + describe('sign', () => { + it('fills the signature', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + + // Act: + const signature = KeyPair.sign(keyPair, payload); + + // Assert: + expect(signature).to.not.deep.equal(new Uint8Array(Signature_Size)); + }); + + it('returns same signature for same data signed by same key pairs', () => { + // Arrange: + const privateKey = convert.uint8ToHex(Crypto.randomBytes(Private_Key_Size)); + const keyPair1 = KeyPair.createKeyPairFromPrivateKeyString(privateKey); + const keyPair2 = KeyPair.createKeyPairFromPrivateKeyString(privateKey); + const payload = Crypto.randomBytes(100); + + // Act: + const signature1 = KeyPair.sign(keyPair1, payload); + const signature2 = KeyPair.sign(keyPair2, payload); + + // Assert: + expect(signature2).to.deep.equal(signature1); + }); + + it('returns different signature for same data signed by different key pairs', () => { + // Arrange: + const keyPair1 = randomKeyPair(); + const keyPair2 = randomKeyPair(); + const payload = Crypto.randomBytes(100); + + // Act: + const signature1 = KeyPair.sign(keyPair1, payload); + const signature2 = KeyPair.sign(keyPair2, payload); + + // Assert: + expect(signature2).to.not.deep.equal(signature1); + }); + + it('cannot sign unsupported data type', () => { + // Arrange: + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(Private_Keys[0]); + + // Assert: + expect(() => { + KeyPair.sign(keyPair, {}); + }).to.throw('unsupported data type'); + }); + }); + + describe('verify', () => { + it('returns true for data signed with same key pair', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(true); + }); + + it('returns false for data signed with different key pair', () => { + // Arrange: + const keyPair1 = randomKeyPair(); + const keyPair2 = randomKeyPair(); + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair1, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair2.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('returns false if signature has been modified', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + + for (let i = 0; i < Signature_Size; i += 4) { + const signature = KeyPair.sign(keyPair, payload); + signature[i] ^= 0xFF; + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified, `signature modified at ${i}`).to.equal(false); + } + }); + + it('returns false if payload has been modified', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(44); + + for (let i = 0; i < payload.length; i += 4) { + const signature = KeyPair.sign(keyPair, payload); + payload[i] ^= 0xFF; + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified, `payload modified at ${i}`).to.equal(false); + } + }); + + it('fails if public key is not on curve', () => { + // Arrange: + const keyPair = randomKeyPair(); + keyPair.publicKey.fill(0); + keyPair.publicKey[keyPair.publicKey.length - 1] = 1; + + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('fails if public key does not correspond to private key', () => { + // Arrange: + const keyPair = randomKeyPair(); + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + for (let i = 0; i < keyPair.publicKey.length; ++i) { + keyPair.publicKey[i] ^= 0xFF; + } + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('rejects zero public key', () => { + // Arrange: + const keyPair = randomKeyPair(); + keyPair.publicKey.fill(0); + + const payload = Crypto.randomBytes(100); + const signature = KeyPair.sign(keyPair, payload); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, payload, signature); + + // Assert: + expect(isVerified).to.equal(false); + }); + + it('cannot verify non canonical signature', () => { + function scalarAddGroupOrder(scalar) { + // 2^252 + 27742317777372353535851937790883648493, little endian + const Group_Order = [ + 0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + ]; + + let r = 0; + for (let i = 0; i < scalar.length; ++i) { + const t = scalar[i] + Group_Order[i]; + scalar[i] += Group_Order[i] + r; + r = (t >> 8) & 0xFF; + } + } + + // Arrange: + const keyPair = randomKeyPair(); + const payload = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]); + const canonicalSignature = KeyPair.sign(keyPair, payload); + + // this is signature with group order added to 'encodedS' part of signature + const nonCanonicalSignature = canonicalSignature.slice(); + scalarAddGroupOrder(nonCanonicalSignature.subarray(32)); + + // Act: + const isCanonicalVerified = KeyPair.verify(keyPair.publicKey, payload, canonicalSignature); + const isNonCanonicalVerified = KeyPair.verify(keyPair.privateKey, payload, nonCanonicalSignature); + + // Assert: + expect(isCanonicalVerified).to.equal(true); + expect(isNonCanonicalVerified).to.equal(false); + }); + }); + + describe('test vectors', () => { + const Input_Data = [ + '8ce03cd60514233b86789729102ea09e867fc6d964dea8c2018ef7d0a2e0e24bf7e348e917116690b9', + 'e4a92208a6fc52282b620699191ee6fb9cf04daf48b48fd542c5e43daa9897763a199aaa4b6f10546109f47ac3564fade0', + '13ed795344c4448a3b256f23665336645a853c5c44dbff6db1b9224b5303b6447fbf8240a2249c55', + 'a2704638434e9f7340f22d08019c4c8e3dbee0df8dd4454a1d70844de11694f4c8ca67fdcb08fed0cec9abb2112b5e5f89', + 'd2488e854dbcdfdb2c9d16c8c0b2fdbc0abb6bac991bfe2b14d359a6bc99d66c00fd60d731ae06d0', + ]; + const Expected_Signatures = [ + 'C9B1342EAB27E906567586803DA265CC15CCACA411E0AEF44508595ACBC47600D0' + + '2527F2EED9AB3F28C856D27E30C3808AF7F22F5F243DE698182D373A9ADE03', + '0755E437ED4C8DD66F1EC29F581F6906AB1E98704ECA94B428A25937DF00EC6479' + + '6F08E5FEF30C6F6C57E4A5FB4C811D617FA661EB6958D55DAE66DDED205501', + '15D6585A2A456E90E89E8774E9D12FE01A6ACFE09936EE41271AA1FBE0551264A9' + + 'FF9329CB6FEE6AE034238C8A91522A6258361D48C5E70A41C1F1C51F55330D', + 'F6FB0D8448FEC0605CF74CFFCC7B7AE8D31D403BCA26F7BD21CB4AC87B00769E9C' + + 'C7465A601ED28CDF08920C73C583E69D621BA2E45266B86B5FCF8165CBE309', + 'E88D8C32FE165D34B775F70657B96D8229FFA9C783E61198A6F3CCB92F487982D0' + + '8F8B16AB9157E2EFC3B78F126088F585E26055741A9F25127AC13E883C9A05', + ]; + + function assertCanSignTestVectors(dataTransform) { + // Sanity: + expect(Private_Keys.length).equal(Input_Data.length); + expect(Private_Keys.length).equal(Expected_Signatures.length); + + for (let i = 0; i < Private_Keys.length; ++i) { + // Arrange: + const inputData = dataTransform(Input_Data[i]); + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(Private_Keys[i]); + + // Act: + const signature = KeyPair.sign(keyPair, inputData); + + // Assert: + const message = `signing with ${Private_Keys[i]}`; + expect(convert.uint8ToHex(signature), message).equal(Expected_Signatures[i]); + } + } + + it('can sign test vectors as hex string', () => { + // Assert: + assertCanSignTestVectors((data) => data); + }); + + it('can sign test vectors as binary', () => { + // Assert: + assertCanSignTestVectors((data) => convert.hexToUint8(data)); + }); + + function assertCanVerifyTestVectors(dataTransform) { + // Sanity: + expect(Private_Keys.length).equal(Input_Data.length); + expect(Private_Keys.length).equal(Expected_Signatures.length); + + for (let i = 0; i < Private_Keys.length; ++i) { + // Arrange: + const inputData = dataTransform(Input_Data[i]); + const keyPair = KeyPair.createKeyPairFromPrivateKeyString(Private_Keys[i]); + const signature = KeyPair.sign(keyPair, inputData); + + // Act: + const isVerified = KeyPair.verify(keyPair.publicKey, inputData, signature); + + // Assert: + const message = `verifying with ${Private_Keys[i]}`; + expect(isVerified, message).equal(true); + } + } + + it('can verify test vectors as hex string', () => { + // Assert: + assertCanVerifyTestVectors((data) => data); + }); + + it('can verify test vectors as binary', () => { + // Assert: + assertCanVerifyTestVectors((data) => convert.hexToUint8(data)); + }); + }); + + describe('derive shared key', () => { + const Salt_Size = 32; + + it('fails if salt is wrong size', () => { + // Arrange: create a salt that is too long + const keyPair = randomKeyPair(); + const publicKey = Crypto.randomBytes(32); + const salt = Crypto.randomBytes(Salt_Size + 1); + + // Act: + expect(() => { + KeyPair.deriveSharedKey(keyPair, publicKey, salt); + }) + .to.throw('salt has unexpected size'); + }); + + it('derives same shared key for both partners', () => { + // Arrange: + const keyPair1 = randomKeyPair(); + const keyPair2 = randomKeyPair(); + const salt = Crypto.randomBytes(Salt_Size); + + // Act: + const sharedKey1 = KeyPair.deriveSharedKey(keyPair1, keyPair2.publicKey, salt); + const sharedKey2 = KeyPair.deriveSharedKey(keyPair2, keyPair1.publicKey, salt); + + // Assert: + expect(sharedKey1).to.deep.equal(sharedKey2); + }); + + it('derives different shared keys for different partners', () => { + // Arrange: + const keyPair = randomKeyPair(); + const publicKey1 = Crypto.randomBytes(32); + const publicKey2 = Crypto.randomBytes(32); + const salt = Crypto.randomBytes(Salt_Size); + + // Act: + const sharedKey1 = KeyPair.deriveSharedKey(keyPair, publicKey1, salt); + const sharedKey2 = KeyPair.deriveSharedKey(keyPair, publicKey2, salt); + + // Assert: + expect(sharedKey1).to.not.deep.equal(sharedKey2); + }); + + it('can derive deterministic shared key from well known inputs', () => { + // Arrange: + const privateKey = convert.hexToUint8('8F545C2816788AB41D352F236D80DBBCBC34705B5F902EFF1F1D88327C7C1300'); + const publicKey = convert.hexToUint8('BF684FB1A85A8C8091EE0442EDDB22E51683802AFA0C0E7C6FE3F3E3E87A8D72'); + const salt = convert.hexToUint8('422C39DF16AAE42A74A5597D6EE2D59CFB4EEB6B3F26D98425B9163A03DAA3B5'); + + // Act: + const sharedKey = KeyPair.deriveSharedKey({ + privateKey, + }, publicKey, salt); + + // Assert: + expect(convert.uint8ToHex(sharedKey)).to.equal('FF9623D28FBC13B6F0E0659117FC7BE294DB3385C046055A6BAC39EDF198D50D'); + }); + }); +}); diff --git a/test/core/crypto/sha3Hasher.spec.ts b/test/core/crypto/sha3Hasher.spec.ts new file mode 100644 index 0000000000..4f9b731238 --- /dev/null +++ b/test/core/crypto/sha3Hasher.spec.ts @@ -0,0 +1,150 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {expect} from 'chai'; +import {SHA3Hasher as sha3Hasher} from '../../../src/core/crypto/SHA3Hasher'; +import {Convert as convert} from '../../../src/core/format'; + +describe('hasher', () => { + const inputs = [ + '', + 'CC', + '41FB', + '1F877C', + 'C1ECFDFC', + '9F2FCC7C90DE090D6B87CD7E9718C1EA6CB21118FC2D5DE9F97E5DB6AC1E9C10' + ]; + + function addSha3Tests(length, expectedOutputs) { + describe('func', () => { + it('can hash test vectors', () => { + // Sanity: + expect(expectedOutputs.length).equal(inputs.length); + + for (let i = 0; i < inputs.length; ++i) { + // Arrange: + const inputHex = inputs[i]; + const inputBuffer = convert.hexToUint8(inputHex); + const expectedHash = expectedOutputs[i]; + + // Act: + const hash = new Uint8Array(length); + sha3Hasher.func(hash, inputBuffer, length); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + } + }); + }); + + describe('object', () => { + it('can hash test vectors', () => { + // Sanity: + expect(expectedOutputs.length).equal(inputs.length); + + for (let i = 0; i < inputs.length; ++i) { + // Arrange: + const inputHex = inputs[i]; + const inputBuffer = convert.hexToUint8(inputHex); + const expectedHash = expectedOutputs[i]; + + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + + // Act: hash the input in two parts + hasher.update(inputBuffer.subarray(0, inputBuffer.length / 2)); + hasher.update(inputBuffer.subarray(inputBuffer.length / 2)); + + const hash = new Uint8Array(length); + hasher.finalize(hash); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + } + }); + + it('can hash string', () => { + // Arrange: + const inputHex = inputs[3]; + const expectedHash = expectedOutputs[3]; + + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + + // Act: + hasher.update(inputHex); + + const hash = new Uint8Array(length); + hasher.finalize(hash); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + }); + + it('cannot hash unsupported data type', () => { + // Arrange: + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + + // Act: + expect(() => hasher.update({})).to.throw('unsupported data type'); + }); + + it('can reuse after reset', () => { + // Arrange: + const inputHex = inputs[3]; + const expectedHash = expectedOutputs[3]; + + const hasher = sha3Hasher.createHasher(length); + hasher.reset(); + hasher.update('ABCD'); + + // Act: + hasher.reset(); + hasher.update(inputHex); + + const hash = new Uint8Array(length); + hasher.finalize(hash); + + // Assert: + expect(convert.uint8ToHex(hash), `hashing ${inputHex}`).equal(expectedHash); + }); + }); + } + + describe('sha3 256', () => { + // https://github.com/gvanas/KeccakCodePackage/blob/master/TestVectors/ShortMsgKAT_SHA3-256.txt + addSha3Tests(32, [ + 'A7FFC6F8BF1ED76651C14756A061D662F580FF4DE43B49FA82D80A4B80F8434A', + '677035391CD3701293D385F037BA32796252BB7CE180B00B582DD9B20AAAD7F0', + '39F31B6E653DFCD9CAED2602FD87F61B6254F581312FB6EEEC4D7148FA2E72AA', + 'BC22345E4BD3F792A341CF18AC0789F1C9C966712A501B19D1B6632CCD408EC5', + 'C5859BE82560CC8789133F7C834A6EE628E351E504E601E8059A0667FF62C124', + '2F1A5F7159E34EA19CDDC70EBF9B81F1A66DB40615D7EAD3CC1F1B954D82A3AF' + ]); + }); + + describe('sha3 512', () => { + // https://github.com/gvanas/KeccakCodePackage/blob/master/TestVectors/ShortMsgKAT_SHA3-512.txt + addSha3Tests(64, [ + 'A69F73CCA23A9AC5C8B567DC185A756E97C982164FE25859E0D1DCC1475C80A615B2123AF1F5F94C11E3E9402C3AC558F500199D95B6D3E301758586281DCD26', + '3939FCC8B57B63612542DA31A834E5DCC36E2EE0F652AC72E02624FA2E5ADEECC7DD6BB3580224B4D6138706FC6E80597B528051230B00621CC2B22999EAA205', + 'AA092865A40694D91754DBC767B5202C546E226877147A95CB8B4C8F8709FE8CD6905256B089DA37896EA5CA19D2CD9AB94C7192FC39F7CD4D598975A3013C69', + 'CB20DCF54955F8091111688BECCEF48C1A2F0D0608C3A575163751F002DB30F40F2F671834B22D208591CFAF1F5ECFE43C49863A53B3225BDFD7C6591BA7658B', + 'D4B4BDFEF56B821D36F4F70AB0D231B8D0C9134638FD54C46309D14FADA92A2840186EED5415AD7CF3969BDFBF2DAF8CCA76ABFE549BE6578C6F4143617A4F1A', + 'B087C90421AEBF87911647DE9D465CBDA166B672EC47CCD4054A7135A1EF885E7903B52C3F2C3FE722B1C169297A91B82428956A02C631A2240F12162C7BC726' + ]); + }); +}); From ae4224ace65a1576e364af3855695f5ce10b7c09 Mon Sep 17 00:00:00 2001 From: Steven Liu Date: Wed, 12 Jun 2019 09:36:37 +0100 Subject: [PATCH 7/7] Added #170 Merged existing buffers and schemas --- .../buffers/AccountLinkTransactionBuffer.ts | 425 ++++++++++ ...countPropertiesAddressTransactionBuffer.ts | 557 +++++++++++++ ...ntPropertiesEntityTypeTransactionBuffer.ts | 520 ++++++++++++ ...ccountPropertiesMosaicTransactionBuffer.ts | 557 +++++++++++++ .../buffers/AddressAliasTransactionBuffer.ts | 479 +++++++++++ .../buffers/AggregateTransactionBuffer.ts | 425 ++++++++++ .../buffers/HashLockTransactionBuffer.ts | 571 +++++++++++++ .../buffers/MosaicAliasTransactionBuffer.ts | 479 +++++++++++ .../MosaicCreationTransactionBuffer.ts | 582 +++++++++++++ .../MosaicSupplyChangeTransactionBuffer.ts | 479 +++++++++++ .../MultisigModificationTransactionBuffer.ts | 571 +++++++++++++ .../NamespaceCreationTransactionBuffer.ts | 512 ++++++++++++ .../buffers/SecretLockTransactionBuffer.ts | 641 ++++++++++++++ .../buffers/SecretProofTransactionBuffer.ts | 549 ++++++++++++ .../buffers/TransferTransactionBuffer.ts | 785 ++++++++++++++++++ .../schemas/AccountLinkTransactionSchema.ts | 44 + ...iesAddressModificationTransactionSchema.ts | 48 ++ ...EntityTypeModificationTransactionSchema.ts | 48 ++ ...tiesMosaicModificationTransactionSchema.ts | 48 ++ .../schemas/AddressAliasTransactionSchema.ts | 44 + .../schemas/AggregateTransactionSchema.ts | 44 + .../schemas/HashLockTransactionSchema.ts | 45 + .../schemas/MosaicAliasTransactionSchema.ts | 44 + .../MosaicCreationTransactionSchema.ts | 63 ++ .../MosaicSupplyChangeTransactionSchema.ts | 44 + .../MultisigModificationTransactionSchema.ts | 49 ++ .../NamespaceCreationTransactionSchema.ts | 47 ++ src/infrastructure/schemas/Schema.ts | 374 +++++++++ .../schemas/SecretLockTransactionSchema.ts | 48 ++ .../schemas/SecretProofTransactionSchema.ts | 47 ++ .../schemas/TransferTransactionSchema.ts | 55 ++ 31 files changed, 9224 insertions(+) create mode 100644 src/infrastructure/buffers/AccountLinkTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AddressAliasTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/AggregateTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/HashLockTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/SecretLockTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/SecretProofTransactionBuffer.ts create mode 100644 src/infrastructure/buffers/TransferTransactionBuffer.ts create mode 100644 src/infrastructure/schemas/AccountLinkTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AddressAliasTransactionSchema.ts create mode 100644 src/infrastructure/schemas/AggregateTransactionSchema.ts create mode 100644 src/infrastructure/schemas/HashLockTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MosaicAliasTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MosaicCreationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts create mode 100644 src/infrastructure/schemas/MultisigModificationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts create mode 100644 src/infrastructure/schemas/Schema.ts create mode 100644 src/infrastructure/schemas/SecretLockTransactionSchema.ts create mode 100644 src/infrastructure/schemas/SecretProofTransactionSchema.ts create mode 100644 src/infrastructure/schemas/TransferTransactionSchema.ts diff --git a/src/infrastructure/buffers/AccountLinkTransactionBuffer.ts b/src/infrastructure/buffers/AccountLinkTransactionBuffer.ts new file mode 100644 index 0000000000..30dde827ce --- /dev/null +++ b/src/infrastructure/buffers/AccountLinkTransactionBuffer.ts @@ -0,0 +1,425 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.AccountLinkTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountLinkTransactionBuffer} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountLinkTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountLinkTransactionBuffer} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.getRootAsAccountLinkTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountLinkTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signerLength = function() { + let offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.signerArray = function() { + let offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.version = function() { + let offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.type = function() { + let offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.fee = function(index) { + const offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.feeLength = function() { + const offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.feeArray = function() { + const offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.deadline = function(index) { + const offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.deadlineLength = function() { + const offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.deadlineArray = function() { + const offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.remoteAccountKey = function(index) { + const offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.remoteAccountKeyLength = function() { + const offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.remoteAccountKeyArray = function() { + const offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.prototype.linkAction = function() { + const offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startAccountLinkTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} remoteAccountKey + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addRemoteAccountKey = function(builder, remoteAccountKeyOffset) { + builder.addFieldOffset(7, remoteAccountKeyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.createRemoteAccountKeyVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountLinkTransactionBuffer.startRemoteAccountKeyVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} linkAction + */ +Catapult.Buffers.AccountLinkTransactionBuffer.addLinkAction = function(builder, linkAction) { + builder.addFieldInt8(8, linkAction, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountLinkTransactionBuffer.endAccountLinkTransactionBuffer = function(builder) { + const offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountLinkTransactionBuffer.finishAccountLinkTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts b/src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts new file mode 100644 index 0000000000..128442e660 --- /dev/null +++ b/src/infrastructure/buffers/AccountPropertiesAddressTransactionBuffer.ts @@ -0,0 +1,557 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.PropertyAddressModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.PropertyAddressModificationBuffer} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.PropertyAddressModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyAddressModificationBuffer} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.getRootAsPropertyAddressModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.PropertyAddressModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.modificationType = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.value = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.valueLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.prototype.valueArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.PropertyAddressModificationBuffer.startPropertyAddressModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.PropertyAddressModificationBuffer.addModificationType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} valueOffset + */ +Catapult.Buffers.PropertyAddressModificationBuffer.addValue = function(builder, valueOffset) { + builder.addFieldOffset(1, valueOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.createValueVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.PropertyAddressModificationBuffer.startValueVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyAddressModificationBuffer.endPropertyAddressModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountPropertiesAddressTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountPropertiesAddressTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountPropertiesAddressTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.getRootAsAccountPropertiesAddressTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountPropertiesAddressTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.propertyType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.modificationCount = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.PropertyAddressModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyAddressModificationBuffer} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new Catapult.Buffers.PropertyAddressModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startAccountPropertiesAddressTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} propertyType + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addPropertyType = function(builder, propertyType) { + builder.addFieldInt8(7, propertyType, 0); +}; + + +/** + * @param {flatbuffers.Builder} builder + * @param {number} modificationCount + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addModificationCount = function(builder, modificationCount) { + builder.addFieldInt8(8, modificationCount, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(9, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.endAccountPropertiesAddressTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountPropertiesAddressTransactionBuffer.finishAccountPropertiesAddressTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts b/src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts new file mode 100644 index 0000000000..0994479bf7 --- /dev/null +++ b/src/infrastructure/buffers/AccountPropertiesEntityTypeTransactionBuffer.ts @@ -0,0 +1,520 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.PropertyEntityTypeModificationBuffer} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.PropertyEntityTypeModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyEntityTypeModificationBuffer} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.getRootAsPropertyEntityTypeModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.PropertyEntityTypeModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.prototype.modificationType = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.prototype.value = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.startPropertyEntityTypeModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.addModificationType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} valueOffset + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.addValue = function(builder, valueOffset) { + builder.addFieldInt16(1, valueOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyEntityTypeModificationBuffer.endPropertyEntityTypeModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.getRootAsAccountPropertiesEntityTypeTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.propertyType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.modificationCount = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.PropertyEntityTypeModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyEntityTypeModificationBuffer} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new Catapult.Buffers.PropertyEntityTypeModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startAccountPropertiesEntityTypeTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} propertyType + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addPropertyType = function(builder, propertyType) { + builder.addFieldInt8(7, propertyType, 0); +}; + + +/** + * @param {flatbuffers.Builder} builder + * @param {number} modificationCount + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addModificationCount = function(builder, modificationCount) { + builder.addFieldInt8(8, modificationCount, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(9, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.endAccountPropertiesEntityTypeTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountPropertiesEntityTypeTransactionBuffer.finishAccountPropertiesEntityTypeTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts b/src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts new file mode 100644 index 0000000000..59241cc50e --- /dev/null +++ b/src/infrastructure/buffers/AccountPropertiesMosaicTransactionBuffer.ts @@ -0,0 +1,557 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.PropertyMosaicModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.PropertyMosaicModificationBuffer} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.PropertyMosaicModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyMosaicModificationBuffer} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.getRootAsPropertyMosaicModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.PropertyMosaicModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.modificationType = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.value = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.valueLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.prototype.valueArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.startPropertyMosaicModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.addModificationType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} valueOffset + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.addValue = function(builder, valueOffset) { + builder.addFieldOffset(1, valueOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.createValueVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.startValueVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.PropertyMosaicModificationBuffer.endPropertyMosaicModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer=} obj + * @returns {Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.getRootAsAccountPropertiesMosaicTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.propertyType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.modificationCount = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.PropertyMosaicModificationBuffer=} obj + * @returns {Catapult.Buffers.PropertyMosaicModificationBuffer} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? (obj || new Catapult.Buffers.PropertyMosaicModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startAccountPropertiesMosaicTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} propertyType + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addPropertyType = function(builder, propertyType) { + builder.addFieldInt8(7, propertyType, 0); +}; + + +/** + * @param {flatbuffers.Builder} builder + * @param {number} modificationCount + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addModificationCount = function(builder, modificationCount) { + builder.addFieldInt8(8, modificationCount, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(9, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.endAccountPropertiesMosaicTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AccountPropertiesMosaicTransactionBuffer.finishAccountPropertiesMosaicTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AddressAliasTransactionBuffer.ts b/src/infrastructure/buffers/AddressAliasTransactionBuffer.ts new file mode 100644 index 0000000000..48dd845503 --- /dev/null +++ b/src/infrastructure/buffers/AddressAliasTransactionBuffer.ts @@ -0,0 +1,479 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.AddressAliasTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AddressAliasTransactionBuffer} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AddressAliasTransactionBuffer=} obj + * @returns {Catapult.Buffers.AddressAliasTransactionBuffer} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.getRootAsAddressAliasTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AddressAliasTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.actionType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.namespaceId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.namespaceIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.namespaceIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.address = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.addressLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.prototype.addressArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startAddressAliasTransactionBuffer = function(builder) { + builder.startObject(10); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} actionType + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addActionType = function(builder, actionType) { + builder.addFieldInt8(7, actionType, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deltaOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addNamespaceId = function(builder, namespaceIdOffset) { + builder.addFieldOffset(8, namespaceIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createNamespaceIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startNamespaceIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.addAddress = function(builder, addressOffset) { + builder.addFieldOffset(9, addressOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.createAddressVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AddressAliasTransactionBuffer.startAddressVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AddressAliasTransactionBuffer.endAddressAliasTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AddressAliasTransactionBuffer.finishAddressAliasTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/AggregateTransactionBuffer.ts b/src/infrastructure/buffers/AggregateTransactionBuffer.ts new file mode 100644 index 0000000000..e2f9f68e83 --- /dev/null +++ b/src/infrastructure/buffers/AggregateTransactionBuffer.ts @@ -0,0 +1,425 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.AggregateTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.AggregateTransactionBuffer} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.AggregateTransactionBuffer=} obj + * @returns {Catapult.Buffers.AggregateTransactionBuffer} + */ +Catapult.Buffers.AggregateTransactionBuffer.getRootAsAggregateTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.AggregateTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactionsSize = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactions = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactionsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.AggregateTransactionBuffer.prototype.transactionsArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.AggregateTransactionBuffer.startAggregateTransactionBuffer = function(builder) { + builder.startObject(9); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.AggregateTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.AggregateTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.AggregateTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} transactionsSize + */ +Catapult.Buffers.AggregateTransactionBuffer.addTransactionsSize = function(builder, transactionsSize) { + builder.addFieldInt32(7, transactionsSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} transactionsOffset + */ +Catapult.Buffers.AggregateTransactionBuffer.addTransactions = function(builder, transactionsOffset) { + builder.addFieldOffset(8, transactionsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.createTransactionsVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.AggregateTransactionBuffer.startTransactionsVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.AggregateTransactionBuffer.endAggregateTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.AggregateTransactionBuffer.finishAggregateTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/HashLockTransactionBuffer.ts b/src/infrastructure/buffers/HashLockTransactionBuffer.ts new file mode 100644 index 0000000000..ed4f0d4d8d --- /dev/null +++ b/src/infrastructure/buffers/HashLockTransactionBuffer.ts @@ -0,0 +1,571 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.HashLockTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.HashLockTransactionBuffer} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.HashLockTransactionBuffer=} obj + * @returns {Catapult.Buffers.HashLockTransactionBuffer} + */ +Catapult.Buffers.HashLockTransactionBuffer.getRootAsHashLockTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.HashLockTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicAmount = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicAmountLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.mosaicAmountArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.duration = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.durationLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.durationArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.hash = function(index) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.hashLength = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.HashLockTransactionBuffer.prototype.hashArray = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.HashLockTransactionBuffer.startHashLockTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.HashLockTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.HashLockTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.HashLockTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(7, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicAmountOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addMosaicAmount = function(builder, mosaicAmountOffset) { + builder.addFieldOffset(8, mosaicAmountOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createMosaicAmountVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startMosaicAmountVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addDuration = function(builder, durationOffset) { + builder.addFieldOffset(9, durationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createDurationVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startDurationVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} hashOffset + */ +Catapult.Buffers.HashLockTransactionBuffer.addHash = function(builder, hashOffset) { + builder.addFieldOffset(10, hashOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.createHashVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.HashLockTransactionBuffer.startHashVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.HashLockTransactionBuffer.endHashLockTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.HashLockTransactionBuffer.finishHashLockTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts b/src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts new file mode 100644 index 0000000000..ee4d523f8d --- /dev/null +++ b/src/infrastructure/buffers/MosaicAliasTransactionBuffer.ts @@ -0,0 +1,479 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicAliasTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicAliasTransactionBuffer} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicAliasTransactionBuffer=} obj + * @returns {Catapult.Buffers.MosaicAliasTransactionBuffer} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.getRootAsMosaicAliasTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicAliasTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.actionType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.namespaceId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.namespaceIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.namespaceIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startMosaicAliasTransactionBuffer = function(builder) { + builder.startObject(10); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} actionType + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addActionType = function(builder, actionType) { + builder.addFieldInt8(7, actionType, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deltaOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addNamespaceId = function(builder, namespaceIdOffset) { + builder.addFieldOffset(8, namespaceIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createNamespaceIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startNamespaceIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(9, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.endMosaicAliasTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MosaicAliasTransactionBuffer.finishMosaicAliasTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts b/src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts new file mode 100644 index 0000000000..eef8821885 --- /dev/null +++ b/src/infrastructure/buffers/MosaicCreationTransactionBuffer.ts @@ -0,0 +1,582 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicCreationTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicCreationTransactionBuffer} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicCreationTransactionBuffer=} obj + * @returns {Catapult.Buffers.MosaicCreationTransactionBuffer} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.getRootAsMosaicCreationTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicCreationTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.nonce = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.nonceLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.nonceArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.numOptionalProperties = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.flags = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.divisibility = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.indicateDuration = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.duration = function(index) { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.durationLength = function() { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.prototype.durationArray = function() { + var offset = this.bb.__offset(this.bb_pos, 30); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startMosaicCreationTransactionBuffer = function(builder) { + builder.startObject(14); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} nonce + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addNonce = function(builder, nonceOffset) { + + builder.addFieldOffset(7, nonceOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createNonceVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startNonceVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(8, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numOptionalProperties + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addNumOptionalProperties = function(builder, numOptionalProperties) { + builder.addFieldInt8(9, numOptionalProperties, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} flags + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addFlags = function(builder, flags) { + builder.addFieldInt8(10, flags, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} divisibility + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addDivisibility = function(builder, divisibility) { + builder.addFieldInt8(11, divisibility, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} indicateDuration + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addIndicateDuration = function(builder, indicateDuration) { + builder.addFieldInt8(12, indicateDuration, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationOffset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.addDuration = function(builder, durationOffset) { + builder.addFieldOffset(13, durationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.createDurationVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.startDurationVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.endMosaicCreationTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MosaicCreationTransactionBuffer.finishMosaicCreationTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts b/src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts new file mode 100644 index 0000000000..0297f46688 --- /dev/null +++ b/src/infrastructure/buffers/MosaicSupplyChangeTransactionBuffer.ts @@ -0,0 +1,479 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicSupplyChangeTransactionBuffer} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicSupplyChangeTransactionBuffer=} obj + * @returns {Catapult.Buffers.MosaicSupplyChangeTransactionBuffer} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.getRootAsMosaicSupplyChangeTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicSupplyChangeTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.direction = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.delta = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deltaLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.prototype.deltaArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startMosaicSupplyChangeTransactionBuffer = function(builder) { + builder.startObject(10); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(7, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} direction + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addDirection = function(builder, direction) { + builder.addFieldInt8(8, direction, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deltaOffset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.addDelta = function(builder, deltaOffset) { + builder.addFieldOffset(9, deltaOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.createDeltaVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.startDeltaVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.endMosaicSupplyChangeTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MosaicSupplyChangeTransactionBuffer.finishMosaicSupplyChangeTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts b/src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts new file mode 100644 index 0000000000..14376de447 --- /dev/null +++ b/src/infrastructure/buffers/MultisigModificationTransactionBuffer.ts @@ -0,0 +1,571 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.CosignatoryModificationBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.CosignatoryModificationBuffer} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.CosignatoryModificationBuffer=} obj + * @returns {Catapult.Buffers.CosignatoryModificationBuffer} + */ +Catapult.Buffers.CosignatoryModificationBuffer.getRootAsCosignatoryModificationBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.CosignatoryModificationBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.cosignatoryPublicKey = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.cosignatoryPublicKeyLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.CosignatoryModificationBuffer.prototype.cosignatoryPublicKeyArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.CosignatoryModificationBuffer.startCosignatoryModificationBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.CosignatoryModificationBuffer.addType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} cosignatoryPublicKeyOffset + */ +Catapult.Buffers.CosignatoryModificationBuffer.addCosignatoryPublicKey = function(builder, cosignatoryPublicKeyOffset) { + builder.addFieldOffset(1, cosignatoryPublicKeyOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.CosignatoryModificationBuffer.createCosignatoryPublicKeyVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.CosignatoryModificationBuffer.startCosignatoryPublicKeyVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.CosignatoryModificationBuffer.endCosignatoryModificationBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.MultisigModificationTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MultisigModificationTransactionBuffer} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MultisigModificationTransactionBuffer=} obj + * @returns {Catapult.Buffers.MultisigModificationTransactionBuffer} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.getRootAsMultisigModificationTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MultisigModificationTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.minRemovalDelta = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.minApprovalDelta = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.numModifications = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.CosignatoryModificationBuffer=} obj + * @returns {Catapult.Buffers.CosignatoryModificationBuffer} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.modifications = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? (obj || new Catapult.Buffers.CosignatoryModificationBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.prototype.modificationsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startMultisigModificationTransactionBuffer = function(builder) { + builder.startObject(11); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} minRemovalDelta + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addMinRemovalDelta = function(builder, minRemovalDelta) { + builder.addFieldInt8(7, minRemovalDelta, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} minApprovalDelta + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addMinApprovalDelta = function(builder, minApprovalDelta) { + builder.addFieldInt8(8, minApprovalDelta, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numModifications + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addNumModifications = function(builder, numModifications) { + builder.addFieldInt8(9, numModifications, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} modificationsOffset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.addModifications = function(builder, modificationsOffset) { + builder.addFieldOffset(10, modificationsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.createModificationsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.startModificationsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.endMultisigModificationTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.MultisigModificationTransactionBuffer.finishMultisigModificationTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts b/src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts new file mode 100644 index 0000000000..47e9657a44 --- /dev/null +++ b/src/infrastructure/buffers/NamespaceCreationTransactionBuffer.ts @@ -0,0 +1,512 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.NamespaceCreationTransactionBuffer} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.NamespaceCreationTransactionBuffer=} obj + * @returns {Catapult.Buffers.NamespaceCreationTransactionBuffer} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.getRootAsNamespaceCreationTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.NamespaceCreationTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceType = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.durationParentId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.durationParentIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.durationParentIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceNameSize = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Encoding=} optionalEncoding + * @returns {string|Uint8Array|null} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.prototype.namespaceName = function(optionalEncoding) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startNamespaceCreationTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} namespaceType + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceType = function(builder, namespaceType) { + builder.addFieldInt8(7, namespaceType, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationParentIdOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addDurationParentId = function(builder, durationParentIdOffset) { + builder.addFieldOffset(8, durationParentIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createDurationParentIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startDurationParentIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} namespaceIdOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceId = function(builder, namespaceIdOffset) { + builder.addFieldOffset(9, namespaceIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.createNamespaceIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.startNamespaceIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} namespaceNameSize + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceNameSize = function(builder, namespaceNameSize) { + builder.addFieldInt8(10, namespaceNameSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} namespaceNameOffset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.addNamespaceName = function(builder, namespaceNameOffset) { + builder.addFieldOffset(11, namespaceNameOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.endNamespaceCreationTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.NamespaceCreationTransactionBuffer.finishNamespaceCreationTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/SecretLockTransactionBuffer.ts b/src/infrastructure/buffers/SecretLockTransactionBuffer.ts new file mode 100644 index 0000000000..4036cdd4c2 --- /dev/null +++ b/src/infrastructure/buffers/SecretLockTransactionBuffer.ts @@ -0,0 +1,641 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.SecretLockTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.SecretLockTransactionBuffer} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.SecretLockTransactionBuffer=} obj + * @returns {Catapult.Buffers.SecretLockTransactionBuffer} + */ +Catapult.Buffers.SecretLockTransactionBuffer.getRootAsSecretLockTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.SecretLockTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicId = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicIdLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicIdArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicAmount = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicAmountLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.mosaicAmountArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.duration = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.durationLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.durationArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.hashAlgorithm = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.secret = function(index) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.secretLength = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.secretArray = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.recipient = function(index) { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.recipientLength = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretLockTransactionBuffer.prototype.recipientArray = function() { + var offset = this.bb.__offset(this.bb_pos, 28); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSecretLockTransactionBuffer = function(builder) { + builder.startObject(13); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.SecretLockTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.SecretLockTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicIdOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addMosaicId = function(builder, mosaicIdOffset) { + builder.addFieldOffset(7, mosaicIdOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createMosaicIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startMosaicIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicAmountOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addMosaicAmount = function(builder, mosaicAmountOffset) { + builder.addFieldOffset(8, mosaicAmountOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createMosaicAmountVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startMosaicAmountVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} durationOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addDuration = function(builder, durationOffset) { + builder.addFieldOffset(9, durationOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createDurationVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startDurationVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} hashAlgorithm + */ +Catapult.Buffers.SecretLockTransactionBuffer.addHashAlgorithm = function(builder, hashAlgorithm) { + builder.addFieldInt8(10, hashAlgorithm, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} secretOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addSecret = function(builder, secretOffset) { + builder.addFieldOffset(11, secretOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createSecretVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startSecretVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} recipientOffset + */ +Catapult.Buffers.SecretLockTransactionBuffer.addRecipient = function(builder, recipientOffset) { + builder.addFieldOffset(12, recipientOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.createRecipientVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretLockTransactionBuffer.startRecipientVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretLockTransactionBuffer.endSecretLockTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.SecretLockTransactionBuffer.finishSecretLockTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/SecretProofTransactionBuffer.ts b/src/infrastructure/buffers/SecretProofTransactionBuffer.ts new file mode 100644 index 0000000000..570f57a886 --- /dev/null +++ b/src/infrastructure/buffers/SecretProofTransactionBuffer.ts @@ -0,0 +1,549 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.SecretProofTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.SecretProofTransactionBuffer} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.SecretProofTransactionBuffer=} obj + * @returns {Catapult.Buffers.SecretProofTransactionBuffer} + */ +Catapult.Buffers.SecretProofTransactionBuffer.getRootAsSecretProofTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.SecretProofTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.hashAlgorithm = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.secret = function(index) { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.secretLength = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.secretArray = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.recipient = function(index) { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.recipientLength = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.recipientArray = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proofSize = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proof = function(index) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proofLength = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.SecretProofTransactionBuffer.prototype.proofArray = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSecretProofTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.SecretProofTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.SecretProofTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} hashAlgorithm + */ +Catapult.Buffers.SecretProofTransactionBuffer.addHashAlgorithm = function(builder, hashAlgorithm) { + builder.addFieldInt8(7, hashAlgorithm, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} secretOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addSecret = function(builder, secretOffset) { + builder.addFieldOffset(8, secretOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createSecretVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startSecretVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} recipientOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addRecipient = function(builder, recipientOffset) { + builder.addFieldOffset(9, recipientOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createRecipientVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startRecipientVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} proofSize + */ +Catapult.Buffers.SecretProofTransactionBuffer.addProofSize = function(builder, proofSize) { + builder.addFieldInt16(10, proofSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} proofOffset + */ +Catapult.Buffers.SecretProofTransactionBuffer.addProof = function(builder, proofOffset) { + builder.addFieldOffset(11, proofOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.createProofVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.SecretProofTransactionBuffer.startProofVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.SecretProofTransactionBuffer.endSecretProofTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.SecretProofTransactionBuffer.finishSecretProofTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/buffers/TransferTransactionBuffer.ts b/src/infrastructure/buffers/TransferTransactionBuffer.ts new file mode 100644 index 0000000000..05be19edfb --- /dev/null +++ b/src/infrastructure/buffers/TransferTransactionBuffer.ts @@ -0,0 +1,785 @@ +/* + * Copyright 2018 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// automatically generated by the FlatBuffers compiler, do not modify + +/** + * @const + * @namespace + */ +var Catapult = Catapult || {}; + +/** + * @const + * @namespace + */ +Catapult.Buffers = Catapult.Buffers || {}; + +/** + * @constructor + */ +Catapult.Buffers.MessageBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MessageBuffer} + */ +Catapult.Buffers.MessageBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MessageBuffer=} obj + * @returns {Catapult.Buffers.MessageBuffer} + */ +Catapult.Buffers.MessageBuffer.getRootAsMessageBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MessageBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MessageBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MessageBuffer.prototype.payload = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MessageBuffer.prototype.payloadLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.MessageBuffer.prototype.payloadArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MessageBuffer.startMessageBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.MessageBuffer.addType = function(builder, type) { + builder.addFieldInt8(0, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} payloadOffset + */ +Catapult.Buffers.MessageBuffer.addPayload = function(builder, payloadOffset) { + builder.addFieldOffset(1, payloadOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MessageBuffer.createPayloadVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MessageBuffer.startPayloadVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MessageBuffer.endMessageBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.MosaicBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.MosaicBuffer} + */ +Catapult.Buffers.MosaicBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.MosaicBuffer=} obj + * @returns {Catapult.Buffers.MosaicBuffer} + */ +Catapult.Buffers.MosaicBuffer.getRootAsMosaicBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.MosaicBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.id = function(index) { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.idLength = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicBuffer.prototype.idArray = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.amount = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.MosaicBuffer.prototype.amountLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.MosaicBuffer.prototype.amountArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.MosaicBuffer.startMosaicBuffer = function(builder) { + builder.startObject(2); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} idOffset + */ +Catapult.Buffers.MosaicBuffer.addId = function(builder, idOffset) { + builder.addFieldOffset(0, idOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicBuffer.createIdVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicBuffer.startIdVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} amountOffset + */ +Catapult.Buffers.MosaicBuffer.addAmount = function(builder, amountOffset) { + builder.addFieldOffset(1, amountOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicBuffer.createAmountVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.MosaicBuffer.startAmountVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.MosaicBuffer.endMosaicBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @constructor + */ +Catapult.Buffers.TransferTransactionBuffer = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {Catapult.Buffers.TransferTransactionBuffer} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {Catapult.Buffers.TransferTransactionBuffer=} obj + * @returns {Catapult.Buffers.TransferTransactionBuffer} + */ +Catapult.Buffers.TransferTransactionBuffer.getRootAsTransferTransactionBuffer = function(bb, obj) { + return (obj || new Catapult.Buffers.TransferTransactionBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.size = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signature = function(index) { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signatureLength = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signatureArray = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signer = function(index) { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signerLength = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.signerArray = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.version = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.type = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.fee = function(index) { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.feeLength = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.feeArray = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.deadline = function(index) { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.deadlineLength = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint32Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.deadlineArray = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? new Uint32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.recipient = function(index) { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.recipientLength = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Uint8Array} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.recipientArray = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.messageSize = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.numMosaics = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {Catapult.Buffers.MessageBuffer=} obj + * @returns {Catapult.Buffers.MessageBuffer|null} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.message = function(obj) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? (obj || new Catapult.Buffers.MessageBuffer).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; +}; + +/** + * @param {number} index + * @param {Catapult.Buffers.MosaicBuffer=} obj + * @returns {Catapult.Buffers.MosaicBuffer} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.mosaics = function(index, obj) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? (obj || new Catapult.Buffers.MosaicBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; +}; + +/** + * @returns {number} + */ +Catapult.Buffers.TransferTransactionBuffer.prototype.mosaicsLength = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +Catapult.Buffers.TransferTransactionBuffer.startTransferTransactionBuffer = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} size + */ +Catapult.Buffers.TransferTransactionBuffer.addSize = function(builder, size) { + builder.addFieldInt32(0, size, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signatureOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addSignature = function(builder, signatureOffset) { + builder.addFieldOffset(1, signatureOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createSignatureVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startSignatureVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} signerOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addSigner = function(builder, signerOffset) { + builder.addFieldOffset(2, signerOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createSignerVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startSignerVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} version + */ +Catapult.Buffers.TransferTransactionBuffer.addVersion = function(builder, version) { + builder.addFieldInt16(3, version, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} type + */ +Catapult.Buffers.TransferTransactionBuffer.addType = function(builder, type) { + builder.addFieldInt16(4, type, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} feeOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addFee = function(builder, feeOffset) { + builder.addFieldOffset(5, feeOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createFeeVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startFeeVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} deadlineOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addDeadline = function(builder, deadlineOffset) { + builder.addFieldOffset(6, deadlineOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createDeadlineVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt32(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startDeadlineVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} recipientOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addRecipient = function(builder, recipientOffset) { + builder.addFieldOffset(7, recipientOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createRecipientVector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startRecipientVector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} messageSize + */ +Catapult.Buffers.TransferTransactionBuffer.addMessageSize = function(builder, messageSize) { + builder.addFieldInt16(8, messageSize, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numMosaics + */ +Catapult.Buffers.TransferTransactionBuffer.addNumMosaics = function(builder, numMosaics) { + builder.addFieldInt8(9, numMosaics, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} messageOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addMessage = function(builder, messageOffset) { + builder.addFieldOffset(10, messageOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} mosaicsOffset + */ +Catapult.Buffers.TransferTransactionBuffer.addMosaics = function(builder, mosaicsOffset) { + builder.addFieldOffset(11, mosaicsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.createMosaicsVector = function(builder, data) { + builder.startVector(4, data.length, 4); + for (var i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +Catapult.Buffers.TransferTransactionBuffer.startMosaicsVector = function(builder, numElems) { + builder.startVector(4, numElems, 4); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +Catapult.Buffers.TransferTransactionBuffer.endTransferTransactionBuffer = function(builder) { + var offset = builder.endObject(); + return offset; +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} offset + */ +Catapult.Buffers.TransferTransactionBuffer.finishTransferTransactionBufferBuffer = function(builder, offset) { + builder.finish(offset); +}; + +// Exports for Node.js and RequireJS +export default Catapult; diff --git a/src/infrastructure/schemas/AccountLinkTransactionSchema.ts b/src/infrastructure/schemas/AccountLinkTransactionSchema.ts new file mode 100644 index 0000000000..5a0e3be1ba --- /dev/null +++ b/src/infrastructure/schemas/AccountLinkTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/AccountLinkTransaction + */ + +/** + * Account Link schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('remoteAccountKey'), + ubyte('linkAction') +]); +export default schema; diff --git a/src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts b/src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts new file mode 100644 index 0000000000..288fb34f23 --- /dev/null +++ b/src/infrastructure/schemas/AccountPropertiesAddressModificationTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + ushort, + tableArray, + uint +} from './Schema'; + +/** + * @module schema/AccountPropertiesAddressModificationTransactionSchema + */ + +/** + * Account properties address transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('propertyType'), + ubyte('modificationCount'), + tableArray('modifications', [ + ubyte('modificationType'), + array('value', TypeSize.BYTE) + ]) +]); diff --git a/src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts b/src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts new file mode 100644 index 0000000000..5c2373b1cc --- /dev/null +++ b/src/infrastructure/schemas/AccountPropertiesEntityTypeModificationTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + ushort, + tableArray, + uint +} from './Schema'; + +/** + * @module schema/AccountPropertiesEntityTypeModificationTransactionSchema + */ + +/** + * Account properties address transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('propertyType'), + ubyte('modificationCount'), + tableArray('modifications', [ + ubyte('modificationType'), + ushort('value') + ]) +]); diff --git a/src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts b/src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts new file mode 100644 index 0000000000..ce323b9e8c --- /dev/null +++ b/src/infrastructure/schemas/AccountPropertiesMosaicModificationTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + ushort, + tableArray, + uint +} from './Schema'; + +/** + * @module schema/AccountPropertiesMosaicModificationTransactionSchema + */ + +/** + * Account properties address transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('propertyType'), + ubyte('modificationCount'), + tableArray('modifications', [ + ubyte('modificationType'), + array('value', TypeSize.INT) + ]) +]); diff --git a/src/infrastructure/schemas/AddressAliasTransactionSchema.ts b/src/infrastructure/schemas/AddressAliasTransactionSchema.ts new file mode 100644 index 0000000000..4a9ceb4d25 --- /dev/null +++ b/src/infrastructure/schemas/AddressAliasTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/AddressAliasTransactionSchema + */ + +/** + * Address alias transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('actionType'), + array('namespaceId', TypeSize.INT), + array('address', TypeSize.BYTE) +]); diff --git a/src/infrastructure/schemas/AggregateTransactionSchema.ts b/src/infrastructure/schemas/AggregateTransactionSchema.ts new file mode 100644 index 0000000000..f27bc0e142 --- /dev/null +++ b/src/infrastructure/schemas/AggregateTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + uint, + ushort +} from './Schema'; + +/** + * @module schema/AggregateTransactionSchema + */ + +/** + * Aggregate transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + uint('transactionsSize'), + array('transactions') +]); + +export default schema; diff --git a/src/infrastructure/schemas/HashLockTransactionSchema.ts b/src/infrastructure/schemas/HashLockTransactionSchema.ts new file mode 100644 index 0000000000..2efbf4ffaa --- /dev/null +++ b/src/infrastructure/schemas/HashLockTransactionSchema.ts @@ -0,0 +1,45 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + uint, + ushort +} from './Schema'; + +/** + * @module schema/HashLockTransactionSchema + */ + +/** + * Hash lock transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('mosaicId', TypeSize.INT), + array('mosaicAmount', TypeSize.INT), + array('duration', TypeSize.INT), + array('hash') +]); +export default schema; diff --git a/src/infrastructure/schemas/MosaicAliasTransactionSchema.ts b/src/infrastructure/schemas/MosaicAliasTransactionSchema.ts new file mode 100644 index 0000000000..b8a69b4c3e --- /dev/null +++ b/src/infrastructure/schemas/MosaicAliasTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MosaicAliasTransactionSchema + */ + +/** + * Mosaic alias transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('actionType'), + array('namespaceId', TypeSize.INT), + array('mosaicId', TypeSize.INT) +]); diff --git a/src/infrastructure/schemas/MosaicCreationTransactionSchema.ts b/src/infrastructure/schemas/MosaicCreationTransactionSchema.ts new file mode 100644 index 0000000000..e9d947652a --- /dev/null +++ b/src/infrastructure/schemas/MosaicCreationTransactionSchema.ts @@ -0,0 +1,63 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MosaicCreationTransactionSchema + */ + +/** + * Mosaic definition creation transaction schema + * @const {module:schema/Schema} + */ +export const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('nonce', TypeSize.BYTE), + array('mosaicId', TypeSize.INT), + ubyte('numOptionalProperties'), + ubyte('flags'), + ubyte('divisibility'), + ubyte('indicateDuration'), + array('duration', TypeSize.INT) +]); + +export const schemaNoDuration = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('nonce', TypeSize.BYTE), + array('mosaicId', TypeSize.INT), + ubyte('numOptionalProperties'), + ubyte('flags'), + ubyte('divisibility') +]); diff --git a/src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts b/src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts new file mode 100644 index 0000000000..19df7503b8 --- /dev/null +++ b/src/infrastructure/schemas/MosaicSupplyChangeTransactionSchema.ts @@ -0,0 +1,44 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MosaicSupplyChangeTransactionSchema + */ + +/** + * Mosaic supply change transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('mosaicId', TypeSize.INT), + ubyte('direction'), + array('delta', TypeSize.INT) +]); diff --git a/src/infrastructure/schemas/MultisigModificationTransactionSchema.ts b/src/infrastructure/schemas/MultisigModificationTransactionSchema.ts new file mode 100644 index 0000000000..91beb8efc6 --- /dev/null +++ b/src/infrastructure/schemas/MultisigModificationTransactionSchema.ts @@ -0,0 +1,49 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + tableArray, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/MultigAggregateModificationTransactionSchema + */ + +/** + * Multisig aggregate modification transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('minRemovalDelta'), + ubyte('minApprovalDelta'), + ubyte('numModifications'), + tableArray('modifications', [ + ubyte('type'), + array('cosignatoryPublicKey') + ]) +]); diff --git a/src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts b/src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts new file mode 100644 index 0000000000..7694dddc5e --- /dev/null +++ b/src/infrastructure/schemas/NamespaceCreationTransactionSchema.ts @@ -0,0 +1,47 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + string, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/NamespaceCreationTransactionSchema + */ + +/** + * Provision namespace transaction schema + * @const {module:schema/Schema} + */ +export default new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('namespaceType'), + array('durationParentId', TypeSize.INT), + array('namespaceId', TypeSize.INT), + ubyte('namespaceNameSize'), + string('name') +]); diff --git a/src/infrastructure/schemas/Schema.ts b/src/infrastructure/schemas/Schema.ts new file mode 100644 index 0000000000..212378e39e --- /dev/null +++ b/src/infrastructure/schemas/Schema.ts @@ -0,0 +1,374 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* eslint-disable no-use-before-define */ + +/** + * In bytes + * @type {{BYTE: number, SHORT: number, INT: number}} + */ +export const TypeSize = { + BYTE: 1, + SHORT: 2, + INT: 4, +}; + +/** + * @param {string} name Attribute name + * @returns {ScalarAttribute} return ScalarAttribute Instance + */ +export const ubyte = (name) => { + return new ScalarAttribute(name, TypeSize.BYTE); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const byte = (name) => { + return new ScalarAttribute(name, TypeSize.BYTE); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const ushort = (name) => { + return new ScalarAttribute(name, TypeSize.SHORT); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const short = (name) => { + return new ScalarAttribute(name, TypeSize.SHORT); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const uint = (name) => { + return new ScalarAttribute(name, TypeSize.INT); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ScalarAttribute} ScalarAttribute Instance + */ +export const int = (name) => { + return new ScalarAttribute(name, TypeSize.INT); +}; + +/** + * + * @param {string} name Attribute Name + * @param {number} typeSize Attribute Byte Size + * @returns {ArrayAttribute} ArrayAttribute Instance + */ +export const array = (name, typeSize = TypeSize.BYTE) => { + return new ArrayAttribute(name, typeSize); +}; + +/** + * + * @param {string} name Attribute Name + * @returns {ArrayAttribute} ArrayAttribute Instance + */ +export const string = (name) => { + return array(name); +}; + +/** + * + * @param {string} name Attribute Name + * @param {module:schema/Schema} schema Table Specific Schema definition + * @returns {TableAttribute} TableAttribute Instance + */ +export const table = (name, schema) => { + return new TableAttribute(name, schema); +}; + +/** + * + * @param {string} name Attribute Name + * @param {module:schema/Schema} schema Schema Definition + * @returns {TableArrayAttribute} TableAttribute Instance + */ +export const tableArray = (name, schema) => { + return new TableArrayAttribute(name, schema); +}; + +/* eslint-disable */ +const readInt32 = (offset, bytes) => { + return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24; +}; + +const readInt16 = (offset, bytes) => { + return bytes[offset] | bytes[offset + 1] << 8; +}; + +const __offset = (val0, fieldPos, bytes) => { + const vtable = val0 - readInt32(val0, bytes); + return fieldPos < readInt16(vtable, bytes) ? readInt16(vtable + fieldPos, bytes) : 0; +}; + +const __vector_length = (offset, bytes) => { + return readInt32(offset + readInt32(offset, bytes), bytes); +}; + +const __indirect = (offset, bytes) => { + return offset + readInt32(offset, bytes); +}; + +const __vector = (offset, bytes) => { + return offset + readInt32(offset, bytes) + 4; +}; + +const findVector = (val0, fieldPos, bytes, size) => { + const offset = __offset(val0, fieldPos, bytes); + const offsetLong = offset + val0; + const vecStart = __vector(offsetLong, bytes); + const vecLength = __vector_length(offsetLong, bytes) * (size ? size : 1); + return offset ? bytes.slice(vecStart, vecStart + vecLength) : 0; +}; + +const findParam = (val0, fieldPos, bytes, numBytes) => { + const offset = __offset(val0, fieldPos, bytes); + return offset ? bytes.slice(offset + val0, offset + val0 + numBytes) : 0; +}; + +const findObjectStartPosition = (val0, fieldPos, bytes) => { + const offset = __offset(val0, fieldPos, bytes); + return __indirect(offset + val0, bytes); +}; + +const findArrayLength = (val0, fieldPos, bytes) => { + const offset = __offset(val0, fieldPos, bytes); + return offset ? __vector_length(val0 + offset, bytes) : 0; +}; + +const findObjectArrayElementStartPosition = (val0, fieldPos, bytes, index) => { + const offset = __offset(val0, fieldPos, bytes); + const vector = __vector(val0 + offset, bytes); + return __indirect(vector + index * 4, bytes); +}; + +/** + * Schema + * @module schema/Schema + */ +export class Schema { + schemaDefinition; + /** + * @constructor + * @param {Array.} schemaDefinition Schema Definition + */ + constructor(schemaDefinition) { + this.schemaDefinition = schemaDefinition; + } + + /** + * + * @param {Uint8Array} bytes flatbuffers bytes + * @returns {Uint8Array} catapult buffer + */ + serialize(bytes) { + let i = 0; + let resultBytes = []; + while (i < this.schemaDefinition.length) { + resultBytes = resultBytes.concat(this.schemaDefinition[i].serialize(bytes, 4 + (i * 2))); + i++; + } + return resultBytes; + } + + /** + * @param {Uint8Array} bytes flatbuffer bytes + * @returns {Array} Array with field name + payload + */ + debugSerialize(bytes) { + let i = 0; + let result: any = []; + while (i < this.schemaDefinition.length) { + result = result.concat({ + name: this.schemaDefinition[i].name, + bytes: this.schemaDefinition[i].debugSerialize(bytes, 4 + i * 2), + }); + i++; + } + return result; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class Attribute { + name: any; + /** + * @constructor + * @param {string} name schema attribute name + */ + constructor(name) { + this.name = name; + } + + /** + * + * @param {Uint8Array} buffer flatbuffer bytes + * @param {number} position attribute possition in flatbuffer bytes + * @param {number} val0 position in case that it is an inner object + */ + serialize(buffer, position, val0 = undefined) { + throw new Error('Unimplemented method'); + } + + /** + * @suppress warnings + * @param {Uint8Array} buffer buffer flatbuffer bytes + * @param {number} position attribute possition in flatbuffer bytes + * @param {number} val0 position in case that it is an inner object + */ + debugSerialize(buffer, position, val0 = undefined) { + throw new Error('Unimplemented method'); + } +} + +// tslint:disable-next-line:max-classes-per-file +export class ScalarAttribute extends Attribute { + typeSize: any; + name: any; + /** + * @constructor + * @param {string} name schema attribute name + * @param {number} typeSize + */ + constructor(name, typeSize) { + super(name); + this.typeSize = typeSize; + } + + serialize(buffer, position, val0 = undefined) { + return findParam(val0 ? val0 : buffer[0], position, buffer, this.typeSize); + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class ArrayAttribute extends Attribute { + typeSize: any; + name: any; + /** + * @constructor + * @param name - {string} + * @param typeSize - {TypeSize} + */ + constructor(name, typeSize) { + super(name); + this.typeSize = typeSize; + } + + serialize(buffer, position, val0 = undefined) { + return findVector(val0 ? val0 : buffer[0], position, buffer, this.typeSize); + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class TableAttribute extends Attribute { + schema: any; + name: any; + /** + * + * @param {string} name + * @param {module:schema/Schema} schema + */ + constructor(name, schema) { + super(name); + this.schema = schema; + } + + serialize(bytes, position, val0 = undefined) { + let result = []; + const messageStartPosition = findObjectStartPosition(val0 ? val0 : bytes[0], position, bytes); + let i = 0; + while (i < this.schema.length) { + result = result.concat(this.schema[i].serialize(bytes, 4 + i * 2, messageStartPosition)); + i++; + } + return result; + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} + +// tslint:disable-next-line:max-classes-per-file +export class TableArrayAttribute extends Attribute { + schema: any; + name: any; + /** + * @constructor + * @param {string} name + * @param {module:schema/Schema} schema + */ + constructor(name, schema) { + super(name); + this.schema = schema; + } + + serialize(bytes, position, val0 = undefined) { + let result = []; + const arrayLength = findArrayLength(val0 ? val0 : bytes[0], position, bytes); + let i = 0; + while (i < arrayLength) { + const startArrayPosition = findObjectArrayElementStartPosition(val0 ? val0 : bytes[0], position, bytes, i); + for (let j = 0; j < this.schema.length; ++j) { + result = result.concat(this.schema[j].serialize(bytes, 4 + j * 2, startArrayPosition)); + } + i++; + } + return result; + } + + debugSerialize(buffer, position, val0 = undefined) { + return { + name: this.name, + bytes: this.serialize(buffer, position, val0), + }; + } +} diff --git a/src/infrastructure/schemas/SecretLockTransactionSchema.ts b/src/infrastructure/schemas/SecretLockTransactionSchema.ts new file mode 100644 index 0000000000..046f02c178 --- /dev/null +++ b/src/infrastructure/schemas/SecretLockTransactionSchema.ts @@ -0,0 +1,48 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/SecretLockTransactionSchema + */ + +/** + * Secret lock transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('mosaicId', TypeSize.INT), + array('mosaicAmount', TypeSize.INT), + array('duration', TypeSize.INT), + ubyte('hashAlgorithm'), + array('secret'), + array('recipient') +]); +export default schema; diff --git a/src/infrastructure/schemas/SecretProofTransactionSchema.ts b/src/infrastructure/schemas/SecretProofTransactionSchema.ts new file mode 100644 index 0000000000..db03f6eaf4 --- /dev/null +++ b/src/infrastructure/schemas/SecretProofTransactionSchema.ts @@ -0,0 +1,47 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/SecretProofTransactionSchema + */ + +/** + * Secret proof transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + ubyte('hashAlgorithm'), + array('secret'), + array('recipient'), + ushort('proofSize'), + array('proof') +]); +export default schema; diff --git a/src/infrastructure/schemas/TransferTransactionSchema.ts b/src/infrastructure/schemas/TransferTransactionSchema.ts new file mode 100644 index 0000000000..eb8efdfd4e --- /dev/null +++ b/src/infrastructure/schemas/TransferTransactionSchema.ts @@ -0,0 +1,55 @@ +/* + * Copyright 2019 NEM + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { + array, + Schema, + table, + tableArray, + TypeSize, + ubyte, + uint, + ushort +} from './Schema'; + +/** + * @module schema/TransferTransactionSchema + */ + +/** + * Transfer transaction schema + * @const {module:schema/Schema} + */ +const schema = new Schema([ + uint('size'), + array('signature'), + array('signer'), + ushort('version'), + ushort('type'), + array('fee', TypeSize.INT), + array('deadline', TypeSize.INT), + array('recipient'), + ushort('messageSize'), + ubyte('numMosaics'), + table('message', [ + ubyte('type'), + array('payload') + ]), + tableArray('mosaics', [ + array('id', TypeSize.INT), + array('amount', TypeSize.INT) + ]) +]); +export default schema;