waves_lib 0.1.0

data/js/node_modules/@waves/waves-transactions/src/validators/validators.ts

@@ -0,0 +1,306 @@
+import {base58Decode, base64Decode, keccak, blake2b, stringToBytes} from '@waves/ts-lib-crypto'
+
+
+const TX_DEFAULTS = {
+    MAX_ATTACHMENT: 140,
+    ALIAS: {
+        AVAILABLE_CHARS: '-.0123456789@_abcdefghijklmnopqrstuvwxyz',
+        MAX_ALIAS_LENGTH: 30,
+        MIN_ALIAS_LENGTH: 4,
+    },
+}
+
+const ASSETS = {
+    NAME_MIN_BYTES: 4,
+    NAME_MAX_BYTES: 16,
+    DESCRIPTION_MAX_BYTES: 1000,
+}
+
+
+export const defaultValue = (value: unknown) => () => value
+
+export const nope = (value: any) => value
+
+export const pipe = (...args: Array<Function>) => (value: unknown) => args.reduce((acc: unknown, cb) => cb(acc), value)
+
+export const validatePipe = (...args: Array<Function>) => (value: unknown) => {
+    let isValid = true
+
+    for (const cb of args) {
+        isValid = !!cb(value)
+        if (!isValid) {
+            return false
+        }
+    }
+
+    return isValid
+}
+
+export const prop = (key: string | number) => (value: unknown) => value ? (value as any)[key] : undefined
+
+export const lte = (ref: any) => (value: any) => ref >= value
+
+export const gte = (ref: any) => (value: any) => ref <= value
+
+export const ifElse = (condition: Function, a: Function, b: Function) => (value: unknown) => condition(value) ? a(value) : b(value)
+
+export const isEq = <T>(reference: T) => (value: unknown) => {
+    switch (true) {
+        case isNumber(value) && isNumber(reference):
+            return Number(value) === Number(reference)
+        case isString(value) && isString(reference):
+            return String(reference) === String(value)
+        case isBoolean(value) && isBoolean(reference):
+            return Boolean(value) === Boolean(reference)
+        default:
+            return reference === value
+    }
+}
+
+export const orEq = (referencesList: Array<unknown>) => (value: unknown) => referencesList.some(isEq(value))
+
+export const isRequired = (required: boolean) => (value: unknown) => !required || value != null
+
+export const isString = (value: unknown) => typeof value === 'string' || value instanceof String
+
+export const isNumber = (value: unknown) => (typeof value === 'number' || value instanceof Number) && !isNaN(Number(value))
+
+export const isNumberLike = (value: unknown) => value != null && !isNaN(Number(value)) && !!(value || value === 0)
+
+export const isNaturalNumberLike = (value: unknown) => value != null && !isNaN(Number(value)) && Number(value) > 0
+
+export const isNaturalNumberOrZeroLike = (value: unknown) => value != null && !isNaN(Number(value)) && Number(value) >= 0
+
+export const isNaturalNumberOrNullLike = (value: unknown) => (!isNaN(Number(value)) && Number(value) > 0) || value === null
+
+export const isBoolean = (value: unknown) => value != null && (typeof value === 'boolean' || value instanceof Boolean)
+
+export const isByteArray = (value: unknown) => {
+    if (!value) {
+        return false
+    }
+
+    const bytes = new Uint8Array(value as any)
+    return bytes.length === (value as any).length && bytes.every((val, index) => isEq(val)((value as any)[index]))
+}
+
+export const isArray = (value: unknown) => Array.isArray(value)
+
+export const bytesLength = (length: number) => (value: unknown) => {
+    try {
+        return Uint8Array.from(value as ArrayLike<number>).length === length
+    } catch (e) {
+        return false
+    }
+}
+
+export const isBase58 = (value: unknown) => {
+    try {
+        base58Decode(value as string)
+    } catch (e) {
+        return false
+    }
+
+    return true
+}
+
+export const isBase64 = (value: unknown) => {
+    try {
+        value = (value as string).replace(/^base64:/, '')
+        base64Decode(value as string)
+    } catch (e) {
+        return false
+    }
+
+    return true
+}
+
+export const isValidAddress = (address: unknown, network?: number) => {
+    if (typeof address !== 'string' || !isBase58(address)) {
+        return false
+    }
+
+    let addressBytes = base58Decode(address)
+
+    if (addressBytes[0] !== 1) {
+        return false
+    }
+
+    if (network != null && addressBytes[1] != network) {
+        return false
+    }
+
+    let key = addressBytes.slice(0, 22)
+    let check = addressBytes.slice(22, 26)
+    let keyHash = keccak(blake2b(key)).slice(0, 4)
+
+    for (let i = 0; i < 4; i++) {
+        if (check[i] !== keyHash[i]) {
+            return false
+        }
+    }
+
+    return true
+}
+
+const validateChars = (chars: string) => (value: string) => value.split('').every((char: string) => chars.includes(char))
+
+
+export const isValidAliasName = ifElse(
+    validateChars(TX_DEFAULTS.ALIAS.AVAILABLE_CHARS),
+    pipe(
+        prop('length'),
+        validatePipe(
+            lte(TX_DEFAULTS.ALIAS.MAX_ALIAS_LENGTH),
+            gte(TX_DEFAULTS.ALIAS.MIN_ALIAS_LENGTH)
+        )
+    ),
+    defaultValue(false)
+)
+
+
+export const isValidAlias = validatePipe(
+    isString,
+    pipe(
+        (value: string) => value.split(':'),
+        ifElse(
+            (value: Array<string>) => value[0] !== 'alias' || value.length !== 3,
+            defaultValue(false),
+            pipe(
+                prop(2),
+                isValidAliasName
+            )
+        )
+    )
+)
+
+export const isHash = validatePipe(
+    isRequired(true),
+    isBase58,
+    pipe(
+        (value: string) => base58Decode(value),
+        bytesLength(32)
+    )
+)
+
+export const isPublicKey = isHash
+
+export const isPublicKeyForEthSuppTx = ifElse(
+    orEq(['', null, undefined]),
+    defaultValue(true),
+    pipe(
+        (value: string) => base58Decode(value),
+        (value: Uint8Array) => {
+            try {
+                return Uint8Array.from(value).length === 32 || Uint8Array.from(value).length === 64
+            } catch (e) {
+                return false
+            }
+        }
+    )
+)
+
+export const isWavesOrAssetId = ifElse(
+    orEq(['', null, undefined, 'WAVES']),
+    defaultValue(true),
+    isHash
+)
+
+export const isAssetId = isHash
+
+export const isAttachment = ifElse(
+    orEq([null, undefined]),
+    defaultValue(true),
+    ifElse(
+        // if valid Data Pair
+        validatePipe(isArray, (data: any[]) => data.every(isValidDataPair)),
+        defaultValue(true),
+        // else if valid base58 or bytearray
+        pipe(
+            ifElse(
+                isBase58,
+                base58Decode,
+                nope
+            ),
+            ifElse(
+                isByteArray,
+                pipe(
+                    prop('length'),
+                    lte(TX_DEFAULTS.MAX_ATTACHMENT)
+                ),
+                defaultValue(false)
+            )
+        )
+    )
+)
+
+
+const validateType = {
+    integer: isNumberLike,
+    boolean: isBoolean,
+    string: isString,
+    binary: isBase64,
+    list: isArray,
+}
+
+export const isValidDataPair = (data: { type: keyof typeof validateType, value: unknown }) =>
+    !!(validateType[data.type] && validateType[data.type](data.value))
+
+export const isValidData = validatePipe(
+    isRequired(true),
+    pipe(prop('key'), validatePipe(isString, (key: string) => !!key)),
+
+    isValidDataPair
+)
+export const isValidDeleteRequest = validatePipe(
+    isRequired(true),
+    pipe(prop('key'), validatePipe(isString, (key: string) => !!key)),
+    ({type, value}: any) => type == null && value == null
+)
+
+export const isValidAssetName = validatePipe(
+    isRequired(true),
+    isString,
+    pipe(
+        stringToBytes,
+        prop('length'),
+        ifElse(
+            gte(ASSETS.NAME_MIN_BYTES),
+            lte(ASSETS.NAME_MAX_BYTES),
+            defaultValue(false)
+        )
+    )
+)
+
+export const isValidAssetDescription = validatePipe(
+    isRequired(false),
+    defaultValue(true),
+    pipe(
+        stringToBytes,
+        prop('length'),
+        lte(ASSETS.DESCRIPTION_MAX_BYTES)
+    )
+)
+
+export const exception = (msg: string) => {
+    throw new Error(msg)
+}
+
+export const isRecipient = ifElse(isValidAddress, defaultValue(true), isValidAlias)
+
+export const validateByShema = (shema: Record<string, Function>, errorTpl: (key: string, value?: unknown) => string) => (tx: Record<string, any>) => {
+    Object.entries(shema).forEach(
+        ([key, cb]) => {
+            const value = prop(key)(tx || {})
+            if (!cb(value)) {
+                exception(errorTpl(key, value))
+            }
+        }
+    )
+
+    return true
+}
+
+export const getError = (key: string, value: any) => {
+    return `tx "${key}", has wrong data: ${JSON.stringify(value)}. Check tx data.`
+}

data/js/node_modules/@waves/waves-transactions/src/validators/wavesAuth.ts

@@ -0,0 +1,15 @@
+import {
+  getError,
+  validateByShema,
+  isNumber,
+  isPublicKey
+} from './validators'
+
+
+const authScheme = {
+  publicKey: isPublicKey,
+  timestamp: isNumber,
+}
+
+
+export const authValidator = validateByShema(authScheme, getError)

data/js/node_modules/asynckit/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Alex Indigo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/js/node_modules/asynckit/README.md

@@ -0,0 +1,233 @@
+# asynckit [![NPM Module](https://img.shields.io/npm/v/asynckit.svg?style=flat)](https://www.npmjs.com/package/asynckit)
+
+Minimal async jobs utility library, with streams support.
+
+[![PhantomJS Build](https://img.shields.io/travis/alexindigo/asynckit/v0.4.0.svg?label=browser&style=flat)](https://travis-ci.org/alexindigo/asynckit)
+[![Linux Build](https://img.shields.io/travis/alexindigo/asynckit/v0.4.0.svg?label=linux:0.12-6.x&style=flat)](https://travis-ci.org/alexindigo/asynckit)
+[![Windows Build](https://img.shields.io/appveyor/ci/alexindigo/asynckit/v0.4.0.svg?label=windows:0.12-6.x&style=flat)](https://ci.appveyor.com/project/alexindigo/asynckit)
+
+[![Coverage Status](https://img.shields.io/coveralls/alexindigo/asynckit/v0.4.0.svg?label=code+coverage&style=flat)](https://coveralls.io/github/alexindigo/asynckit?branch=master)
+[![Dependency Status](https://img.shields.io/david/alexindigo/asynckit/v0.4.0.svg?style=flat)](https://david-dm.org/alexindigo/asynckit)
+[![bitHound Overall Score](https://www.bithound.io/github/alexindigo/asynckit/badges/score.svg)](https://www.bithound.io/github/alexindigo/asynckit)
+
+<!-- [![Readme](https://img.shields.io/badge/readme-tested-brightgreen.svg?style=flat)](https://www.npmjs.com/package/reamde) -->
+
+AsyncKit provides harness for `parallel` and `serial` iterators over list of items represented by arrays or objects.
+Optionally it accepts abort function (should be synchronously return by iterator for each item), and terminates left over jobs upon an error event. For specific iteration order built-in (`ascending` and `descending`) and custom sort helpers also supported, via `asynckit.serialOrdered` method.
+
+It ensures async operations to keep behavior more stable and prevent `Maximum call stack size exceeded` errors, from sync iterators.
+
+| compression        |     size |
+| :----------------- | -------: |
+| asynckit.js        | 12.34 kB |
+| asynckit.min.js    |  4.11 kB |
+| asynckit.min.js.gz |  1.47 kB |
+
+
+## Install
+
+```sh
+$ npm install --save asynckit
+```
+
+## Examples
+
+### Parallel Jobs
+
+Runs iterator over provided array in parallel. Stores output in the `result` array,
+on the matching positions. In unlikely event of an error from one of the jobs,
+will terminate rest of the active jobs (if abort function is provided)
+and return error along with salvaged data to the main callback function.
+
+#### Input Array
+
+```javascript
+var parallel = require('asynckit').parallel
+  , assert   = require('assert')
+  ;
+
+var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
+  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
+  , expectedTarget = [ 1, 1, 2, 4, 8, 16, 32, 64 ]
+  , target         = []
+  ;
+
+parallel(source, asyncJob, function(err, result)
+{
+  assert.deepEqual(result, expectedResult);
+  assert.deepEqual(target, expectedTarget);
+});
+
+// async job accepts one element from the array
+// and a callback function
+function asyncJob(item, cb)
+{
+  // different delays (in ms) per item
+  var delay = item * 25;
+
+  // pretend different jobs take different time to finish
+  // and not in consequential order
+  var timeoutId = setTimeout(function() {
+    target.push(item);
+    cb(null, item * 2);
+  }, delay);
+
+  // allow to cancel "leftover" jobs upon error
+  // return function, invoking of which will abort this job
+  return clearTimeout.bind(null, timeoutId);
+}
+```
+
+More examples could be found in [test/test-parallel-array.js](test/test-parallel-array.js).
+
+#### Input Object
+
+Also it supports named jobs, listed via object.
+
+```javascript
+var parallel = require('asynckit/parallel')
+  , assert   = require('assert')
+  ;
+
+var source         = { first: 1, one: 1, four: 4, sixteen: 16, sixtyFour: 64, thirtyTwo: 32, eight: 8, two: 2 }
+  , expectedResult = { first: 2, one: 2, four: 8, sixteen: 32, sixtyFour: 128, thirtyTwo: 64, eight: 16, two: 4 }
+  , expectedTarget = [ 1, 1, 2, 4, 8, 16, 32, 64 ]
+  , expectedKeys   = [ 'first', 'one', 'two', 'four', 'eight', 'sixteen', 'thirtyTwo', 'sixtyFour' ]
+  , target         = []
+  , keys           = []
+  ;
+
+parallel(source, asyncJob, function(err, result)
+{
+  assert.deepEqual(result, expectedResult);
+  assert.deepEqual(target, expectedTarget);
+  assert.deepEqual(keys, expectedKeys);
+});
+
+// supports full value, key, callback (shortcut) interface
+function asyncJob(item, key, cb)
+{
+  // different delays (in ms) per item
+  var delay = item * 25;
+
+  // pretend different jobs take different time to finish
+  // and not in consequential order
+  var timeoutId = setTimeout(function() {
+    keys.push(key);
+    target.push(item);
+    cb(null, item * 2);
+  }, delay);
+
+  // allow to cancel "leftover" jobs upon error
+  // return function, invoking of which will abort this job
+  return clearTimeout.bind(null, timeoutId);
+}
+```
+
+More examples could be found in [test/test-parallel-object.js](test/test-parallel-object.js).
+
+### Serial Jobs
+
+Runs iterator over provided array sequentially. Stores output in the `result` array,
+on the matching positions. In unlikely event of an error from one of the jobs,
+will not proceed to the rest of the items in the list
+and return error along with salvaged data to the main callback function.
+
+#### Input Array
+
+```javascript
+var serial = require('asynckit/serial')
+  , assert = require('assert')
+  ;
+
+var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
+  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
+  , expectedTarget = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
+  , target         = []
+  ;
+
+serial(source, asyncJob, function(err, result)
+{
+  assert.deepEqual(result, expectedResult);
+  assert.deepEqual(target, expectedTarget);
+});
+
+// extended interface (item, key, callback)
+// also supported for arrays
+function asyncJob(item, key, cb)
+{
+  target.push(key);
+
+  // it will be automatically made async
+  // even it iterator "returns" in the same event loop
+  cb(null, item * 2);
+}
+```
+
+More examples could be found in [test/test-serial-array.js](test/test-serial-array.js).
+
+#### Input Object
+
+Also it supports named jobs, listed via object.
+
+```javascript
+var serial = require('asynckit').serial
+  , assert = require('assert')
+  ;
+
+var source         = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
+  , expectedResult = [ 2, 2, 8, 32, 128, 64, 16, 4 ]
+  , expectedTarget = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
+  , target         = []
+  ;
+
+var source         = { first: 1, one: 1, four: 4, sixteen: 16, sixtyFour: 64, thirtyTwo: 32, eight: 8, two: 2 }
+  , expectedResult = { first: 2, one: 2, four: 8, sixteen: 32, sixtyFour: 128, thirtyTwo: 64, eight: 16, two: 4 }
+  , expectedTarget = [ 1, 1, 4, 16, 64, 32, 8, 2 ]
+  , target         = []
+  ;
+
+
+serial(source, asyncJob, function(err, result)
+{
+  assert.deepEqual(result, expectedResult);
+  assert.deepEqual(target, expectedTarget);
+});
+
+// shortcut interface (item, callback)
+// works for object as well as for the arrays
+function asyncJob(item, cb)
+{
+  target.push(item);
+
+  // it will be automatically made async
+  // even it iterator "returns" in the same event loop
+  cb(null, item * 2);
+}
+```
+
+More examples could be found in [test/test-serial-object.js](test/test-serial-object.js).
+
+_Note: Since _object_ is an _unordered_ collection of properties,
+it may produce unexpected results with sequential iterations.
+Whenever order of the jobs' execution is important please use `serialOrdered` method._
+
+### Ordered Serial Iterations
+
+TBD
+
+For example [compare-property](compare-property) package.
+
+### Streaming interface
+
+TBD
+
+## Want to Know More?
+
+More examples can be found in [test folder](test/).
+
+Or open an [issue](https://github.com/alexindigo/asynckit/issues) with questions and/or suggestions.
+
+## License
+
+AsyncKit is licensed under the MIT license.

data/js/node_modules/asynckit/bench.js

@@ -0,0 +1,76 @@
+/* eslint no-console: "off" */
+
+var asynckit = require('./')
+  , async    = require('async')
+  , assert   = require('assert')
+  , expected = 0
+  ;
+
+var Benchmark = require('benchmark');
+var suite = new Benchmark.Suite;
+
+var source = [];
+for (var z = 1; z < 100; z++)
+{
+  source.push(z);
+  expected += z;
+}
+
+suite
+// add tests
+
+.add('async.map', function(deferred)
+{
+  var total = 0;
+
+  async.map(source,
+  function(i, cb)
+  {
+    setImmediate(function()
+    {
+      total += i;
+      cb(null, total);
+    });
+  },
+  function(err, result)
+  {
+    assert.ifError(err);
+    assert.equal(result[result.length - 1], expected);
+    deferred.resolve();
+  });
+}, {'defer': true})
+
+
+.add('asynckit.parallel', function(deferred)
+{
+  var total = 0;
+
+  asynckit.parallel(source,
+  function(i, cb)
+  {
+    setImmediate(function()
+    {
+      total += i;
+      cb(null, total);
+    });
+  },
+  function(err, result)
+  {
+    assert.ifError(err);
+    assert.equal(result[result.length - 1], expected);
+    deferred.resolve();
+  });
+}, {'defer': true})
+
+
+// add listeners
+.on('cycle', function(ev)
+{
+  console.log(String(ev.target));
+})
+.on('complete', function()
+{
+  console.log('Fastest is ' + this.filter('fastest').map('name'));
+})
+// run async
+.run({ 'async': true });

data/js/node_modules/asynckit/index.js

@@ -0,0 +1,6 @@
+module.exports =
+{
+  parallel      : require('./parallel.js'),
+  serial        : require('./serial.js'),
+  serialOrdered : require('./serialOrdered.js')
+};

data/js/node_modules/asynckit/lib/abort.js

@@ -0,0 +1,29 @@
+// API
+module.exports = abort;
+
+/**
+ * Aborts leftover active jobs
+ *
+ * @param {object} state - current state object
+ */
+function abort(state)
+{
+  Object.keys(state.jobs).forEach(clean.bind(state));
+
+  // reset leftover jobs
+  state.jobs = {};
+}
+
+/**
+ * Cleans up leftover job by invoking abort function for the provided job id
+ *
+ * @this  state
+ * @param {string|number} key - job id to abort
+ */
+function clean(key)
+{
+  if (typeof this.jobs[key] == 'function')
+  {
+    this.jobs[key]();
+  }
+}