@steemit/steem-js 0.8.0 → 1.0.1

package/lib/api/transports/http.js

@@ -1,157 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-exports.jsonRpc = jsonRpc;
-var _crossFetch = _interopRequireDefault(require("cross-fetch"));
-var _debug = _interopRequireDefault(require("debug"));
-var _retry = _interopRequireDefault(require("retry"));
-var _base = _interopRequireDefault(require("./base"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const debug = (0, _debug.default)('steem:http');
-class RPCError extends Error {
-  constructor(rpcError) {
-    super(rpcError.message);
-    this.name = 'RPCError';
-    this.code = rpcError.code;
-    this.data = rpcError.data;
-  }
-}
-
-/**
- * Makes a JSON-RPC request using `fetch` or a user-provided `fetchMethod`.
- *
- * @param {string} uri - The URI to the JSON-RPC endpoint.
- * @param {string} options.method - The remote JSON-RPC method to call.
- * @param {string} options.id - ID for the request, for matching to a response.
- * @param {*} options.params  - The params for the remote method.
- * @param {function} [options.fetchMethod=fetch] - A function with the same
- * signature as `fetch`, which can be used to make the network request, or for
- * stubbing in tests.
- * @param {number} [options.timeoutMs=30000] - Request timeout in milliseconds.
- */
-function jsonRpc(uri, {
-  method,
-  id,
-  params,
-  fetchMethod = _crossFetch.default,
-  timeoutMs = 30000
-}) {
-  const payload = {
-    id,
-    jsonrpc: '2.0',
-    method,
-    params
-  };
-  let timeoutId = null;
-
-  // Create a promise that will reject after the timeout
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(`Request timeout after ${timeoutMs}ms`));
-    }, timeoutMs);
-  });
-
-  // Create the fetch promise
-  const fetchPromise = fetchMethod(uri, {
-    body: JSON.stringify(payload),
-    method: 'post',
-    mode: 'cors',
-    headers: {
-      Accept: 'application/json, text/plain, */*',
-      'Content-Type': 'application/json'
-    }
-  }).then(res => {
-    if (!res.ok) {
-      throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-    }
-    return res.json();
-  }).then(rpcRes => {
-    if (rpcRes.id !== id) {
-      throw new Error(`Invalid response id: ${rpcRes.id}`);
-    }
-    if (rpcRes.error) {
-      throw new RPCError(rpcRes.error);
-    }
-    return rpcRes.result;
-  });
-
-  // Race the fetch against the timeout
-  return Promise.race([fetchPromise, timeoutPromise]).finally(() => {
-    // Clear the timeout to avoid memory leaks
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  });
-}
-class HttpTransport extends _base.default {
-  send(api, data, callback) {
-    if (this.options.useAppbaseApi) {
-      api = 'condenser_api';
-    }
-    debug('Steem::send', api, data);
-    const id = data.id || this.id++;
-    const params = [api, data.method, data.params];
-    const retriable = this.retriable(api, data);
-    const fetchMethod = this.options.fetchMethod;
-
-    // Use a longer timeout for broadcast operations (60s) and standard operations (30s)
-    const timeoutMs = this.isBroadcastOperation(data.method) ? 60000 : 30000;
-    if (retriable) {
-      retriable.attempt(currentAttempt => {
-        jsonRpc(this.options.uri, {
-          method: 'call',
-          id,
-          params,
-          fetchMethod,
-          timeoutMs
-        }).then(res => {
-          callback(null, res);
-        }, err => {
-          if (retriable.retry(err)) {
-            return;
-          }
-          callback(retriable.mainError());
-        });
-      });
-    } else {
-      jsonRpc(this.options.uri, {
-        method: 'call',
-        id,
-        params,
-        fetchMethod,
-        timeoutMs
-      }).then(res => {
-        callback(null, res);
-      }, err => {
-        callback(err);
-      });
-    }
-  }
-  isBroadcastOperation(method) {
-    return this.nonRetriableOperations.some(op => op === method);
-  }
-  get nonRetriableOperations() {
-    return this.options.nonRetriableOperations || ['broadcast_transaction', 'broadcast_transaction_with_callback', 'broadcast_transaction_synchronous', 'broadcast_block'];
-  }
-
-  // An object which can be used to track retries.
-  retriable(api, data) {
-    if (this.isBroadcastOperation(data.method)) {
-      // Do not retry if the operation is non-retriable.
-      return null;
-    } else if (Object(this.options.retry) === this.options.retry) {
-      // If `this.options.retry` is a map of options, pass those to operation.
-      return _retry.default.operation(this.options.retry);
-    } else if (this.options.retry) {
-      // If `this.options.retry` is `true`, use default options.
-      return _retry.default.operation();
-    } else {
-      // Otherwise, don't retry.
-      return null;
-    }
-  }
-}
-exports.default = HttpTransport;

package/lib/api/transports/index.js

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _http = _interopRequireDefault(require("./http"));
-var _ws = _interopRequireDefault(require("./ws"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-var _default = exports.default = {
-  http: _http.default,
-  ws: _ws.default
-};

package/lib/api/transports/ws.js

@@ -1,128 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _bluebird = _interopRequireDefault(require("bluebird"));
-var _detectNode = _interopRequireDefault(require("detect-node"));
-var _debug = _interopRequireDefault(require("debug"));
-var _base = _interopRequireDefault(require("./base"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-let WebSocket;
-if (_detectNode.default) {
-  WebSocket = require('ws'); // eslint-disable-line global-require
-} else if (typeof window !== 'undefined') {
-  WebSocket = window.WebSocket;
-} else {
-  throw new Error("Couldn't decide on a `WebSocket` class");
-}
-const debug = (0, _debug.default)('steem:ws');
-class WsTransport extends _base.default {
-  constructor(options = {}) {
-    super(Object.assign({
-      id: 0
-    }, options));
-    this._requests = new Map();
-    this.inFlight = 0;
-    this.isOpen = false;
-  }
-  start() {
-    if (this.startPromise) {
-      return this.startPromise;
-    }
-    this.startPromise = new _bluebird.default((resolve, reject) => {
-      this.ws = new WebSocket(this.options.websocket);
-      this.ws.onerror = err => {
-        this.startPromise = null;
-        reject(err);
-      };
-      this.ws.onopen = () => {
-        this.isOpen = true;
-        this.ws.onerror = this.onError.bind(this);
-        this.ws.onmessage = this.onMessage.bind(this);
-        this.ws.onclose = this.onClose.bind(this);
-        resolve();
-      };
-    });
-    return this.startPromise;
-  }
-  stop() {
-    debug('Stopping...');
-    this.startPromise = null;
-    this.isOpen = false;
-    this._requests.clear();
-    if (this.ws) {
-      this.ws.onerror = this.ws.onmessage = this.ws.onclose = null;
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  send(api, data, callback) {
-    debug('Steem::send', api, data);
-    return this.start().then(() => {
-      const deferral = {};
-      new _bluebird.default((resolve, reject) => {
-        deferral.resolve = val => {
-          resolve(val);
-          callback(null, val);
-        };
-        deferral.reject = val => {
-          reject(val);
-          callback(val);
-        };
-      });
-      if (this.options.useAppbaseApi) {
-        api = 'condenser_api';
-      }
-      const _request = {
-        deferral,
-        startedAt: Date.now(),
-        message: {
-          id: data.id || this.id++,
-          method: 'call',
-          jsonrpc: '2.0',
-          params: [api, data.method, data.params]
-        }
-      };
-      this.inFlight++;
-      this._requests.set(_request.message.id, _request);
-      this.ws.send(JSON.stringify(_request.message));
-      return deferral;
-    });
-  }
-  onError(error) {
-    for (let _request of this._requests) {
-      _request.deferral.reject(error);
-    }
-    this.stop();
-  }
-  onClose() {
-    const error = new Error('Connection was closed');
-    for (let _request of this._requests) {
-      _request.deferral.reject(error);
-    }
-    this._requests.clear();
-  }
-  onMessage(websocketMessage) {
-    const message = JSON.parse(websocketMessage.data);
-    debug('-- Steem.onMessage -->', message.id);
-    if (!this._requests.has(message.id)) {
-      throw new Error(`Panic: no request in queue for message id ${message.id}`);
-    }
-    const _request = this._requests.get(message.id);
-    this._requests.delete(message.id);
-    const errorCause = message.error;
-    if (errorCause) {
-      const err = new Error(
-      // eslint-disable-next-line prefer-template
-      (errorCause.message || 'Failed to complete operation') + ' (see err.payload for the full error payload)');
-      err.payload = message;
-      _request.deferral.reject(err);
-    } else {
-      this.emit('track-performance', _request.message.method, Date.now() - _request.startedAt);
-      _request.deferral.resolve(message.result);
-    }
-  }
-}
-exports.default = WsTransport;

package/lib/auth/ecc/index.js

@@ -1,13 +0,0 @@
-"use strict";
-
-module.exports = {
-  Address: require("./src/address"),
-  Aes: require("./src/aes"),
-  PrivateKey: require("./src/key_private"),
-  PublicKey: require("./src/key_public"),
-  Signature: require("./src/signature"),
-  brainKey: require("./src/brain_key"),
-  key_utils: require("./src/key_utils"),
-  hash: require("./src/hash"),
-  ecc_config: require("../../config")
-};

package/lib/auth/ecc/src/address.js

@@ -1,54 +0,0 @@
-"use strict";
-
-const assert = require('assert');
-const config = require('../../../config');
-const hash = require('./hash');
-const base58 = require('bs58');
-
-/** Addresses are shortened non-reversable hashes of a public key.  The full PublicKey is preferred.
-    @deprecated
-*/
-class Address {
-  constructor(addy) {
-    this.addy = addy;
-  }
-  static fromBuffer(buffer) {
-    const _hash = hash.sha512(buffer);
-    const addy = hash.ripemd160(_hash);
-    return new Address(addy);
-  }
-  static fromString(string, address_prefix = config.get('address_prefix')) {
-    const prefix = string.slice(0, address_prefix.length);
-    assert.equal(address_prefix, prefix, `Expecting key to begin with ${address_prefix}, instead got ${prefix}`);
-    let addy = string.slice(address_prefix.length);
-    addy = new Buffer.from(base58.decode(addy), 'binary');
-    const checksum = addy.slice(-4);
-    addy = addy.slice(0, -4);
-    let new_checksum = hash.ripemd160(addy);
-    new_checksum = new_checksum.slice(0, 4);
-    assert.deepEqual(checksum, new_checksum, 'Checksum did not match');
-    return new Address(addy);
-  }
-
-  /** @return Address - Compressed PTS format (by default) */
-  static fromPublic(public_key, compressed = true, version = 56) {
-    const sha2 = hash.sha256(public_key.toBuffer(compressed));
-    const rep = hash.ripemd160(sha2);
-    const versionBuffer = new Buffer.alloc(1);
-    versionBuffer.writeUInt8(0xFF & version, 0);
-    const addr = Buffer.concat([versionBuffer, rep]);
-    let check = hash.sha256(addr);
-    check = hash.sha256(check);
-    const buffer = Buffer.concat([addr, check.slice(0, 4)]);
-    return new Address(hash.ripemd160(buffer));
-  }
-  toBuffer() {
-    return this.addy;
-  }
-  toString(address_prefix = config.get('address_prefix')) {
-    const checksum = hash.ripemd160(this.addy);
-    const addy = Buffer.concat([this.addy, checksum.slice(0, 4)]);
-    return address_prefix + base58.encode(addy);
-  }
-}
-module.exports = Address;

package/lib/auth/ecc/src/aes.js

@@ -1,148 +0,0 @@
-"use strict";
-
-const secureRandom = require('secure-random');
-const ByteBuffer = require('bytebuffer');
-const crypto = require('browserify-aes');
-const assert = require('assert');
-const PublicKey = require('./key_public');
-const PrivateKey = require('./key_private');
-const hash = require('./hash');
-const Long = ByteBuffer.Long;
-
-/**
-    Spec: http://localhost:3002/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
-    @throws {Error|TypeError} - "Invalid Key, ..."
-    @arg {PrivateKey} private_key - required and used for decryption
-    @arg {PublicKey} public_key - required and used to calculate the shared secret
-    @arg {string} [nonce = uniqueNonce()] - assigned a random unique uint64
-
-    @return {object}
-    @property {string} nonce - random or unique uint64, provides entropy when re-using the same private/public keys.
-    @property {Buffer} message - Plain text message
-    @property {number} checksum - shared secret checksum
-*/
-function encrypt(private_key, public_key, message, nonce = uniqueNonce()) {
-  return crypt(private_key, public_key, nonce, message);
-}
-
-/**
-    Spec: http://localhost:3002/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
-    @arg {PrivateKey} private_key - required and used for decryption
-    @arg {PublicKey} public_key - required and used to calculate the shared secret
-    @arg {string} nonce - random or unique uint64, provides entropy when re-using the same private/public keys.
-    @arg {Buffer} message - Encrypted or plain text message
-    @arg {number} checksum - shared secret checksum
-    @throws {Error|TypeError} - "Invalid Key, ..."
-    @return {Buffer} - message
-*/
-function decrypt(private_key, public_key, nonce, message, checksum) {
-  return crypt(private_key, public_key, nonce, message, checksum).message;
-}
-
-/**
-    @arg {Buffer} message - Encrypted or plain text message (see checksum)
-    @arg {number} checksum - shared secret checksum (null to encrypt, non-null to decrypt)
-*/
-function crypt(private_key, public_key, nonce, message, checksum) {
-  private_key = toPrivateObj(private_key);
-  if (!private_key) throw new TypeError('private_key is required');
-  public_key = toPublicObj(public_key);
-  if (!public_key) throw new TypeError('public_key is required');
-  nonce = toLongObj(nonce);
-  if (!nonce) throw new TypeError('nonce is required');
-  if (!Buffer.isBuffer(message)) {
-    if (typeof message !== 'string') throw new TypeError('message should be buffer or string');
-    message = new Buffer.from(message, 'binary');
-  }
-  if (checksum && typeof checksum !== 'number') throw new TypeError('checksum should be a number');
-  const S = private_key.get_shared_secret(public_key);
-  let ebuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-  ebuf.writeUint64(nonce);
-  ebuf.append(S.toString('binary'), 'binary');
-  ebuf = new Buffer.from(ebuf.copy(0, ebuf.offset).toBinary(), 'binary');
-  const encryption_key = hash.sha512(ebuf);
-
-  // D E B U G
-  // console.log('crypt', {
-  //     priv_to_pub: private_key.toPublicKey().toString(),
-  //     pub: public_key.toString(),
-  //     nonce: nonce.toString(),
-  //     message: message.length,
-  //     checksum,
-  //     S: S.toString('hex'),
-  //     encryption_key: encryption_key.toString('hex'),
-  // })
-
-  const iv = encryption_key.slice(32, 48);
-  const key = encryption_key.slice(0, 32);
-
-  // check is first 64 bit of sha256 hash treated as uint64_t truncated to 32 bits.
-  let check = hash.sha256(encryption_key);
-  check = check.slice(0, 4);
-  const cbuf = ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-  check = cbuf.readUint32();
-  if (checksum) {
-    if (check !== checksum) throw new Error('Invalid key');
-    message = cryptoJsDecrypt(message, key, iv);
-  } else {
-    message = cryptoJsEncrypt(message, key, iv);
-  }
-  return {
-    nonce,
-    message,
-    checksum: check
-  };
-}
-
-/** This method does not use a checksum, the returned data must be validated some other way.
-    @arg {string|Buffer} ciphertext - binary format
-    @return {Buffer}
-*/
-function cryptoJsDecrypt(message, key, iv) {
-  assert(message, "Missing cipher text");
-  message = toBinaryBuffer(message);
-  const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
-  // decipher.setAutoPadding(true)
-  message = Buffer.concat([decipher.update(message), decipher.final()]);
-  return message;
-}
-
-/** This method does not use a checksum, the returned data must be validated some other way.
-    @arg {string|Buffer} plaintext - binary format
-    @return {Buffer} binary
-*/
-function cryptoJsEncrypt(message, key, iv) {
-  assert(message, "Missing plain text");
-  message = toBinaryBuffer(message);
-  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
-  // cipher.setAutoPadding(true)
-  message = Buffer.concat([cipher.update(message), cipher.final()]);
-  return message;
-}
-
-/** @return {string} unique 64 bit unsigned number string.  Being time based, this is careful to never choose the same nonce twice.  This value could be recorded in the blockchain for a long time.
-*/
-function uniqueNonce() {
-  if (unique_nonce_entropy === null) {
-    const b = secureRandom.randomUint8Array(2);
-    unique_nonce_entropy = parseInt(b[0] << 8 | b[1], 10);
-  }
-  let long = Long.fromNumber(Date.now());
-  const entropy = ++unique_nonce_entropy % 0xFFFF;
-  // console.log('uniqueNonce date\t', ByteBuffer.allocate(8).writeUint64(long).toHex(0))
-  // console.log('uniqueNonce entropy\t', ByteBuffer.allocate(8).writeUint64(Long.fromNumber(entropy)).toHex(0))
-  long = long.shiftLeft(16).or(Long.fromNumber(entropy));
-  // console.log('uniqueNonce final\t', ByteBuffer.allocate(8).writeUint64(long).toHex(0))
-  return long.toString();
-}
-let unique_nonce_entropy = null;
-// for(let i=1; i < 10; i++) key.uniqueNonce()
-
-const toPrivateObj = o => o ? o.d ? o : PrivateKey.fromWif(o) : o /*null or undefined*/;
-const toPublicObj = o => o ? o.Q ? o : PublicKey.fromString(o) : o /*null or undefined*/;
-const toLongObj = o => o ? Long.isLong(o) ? o : Long.fromString(o) : o;
-const toBinaryBuffer = o => o ? Buffer.isBuffer(o) ? o : new Buffer.from(o, 'binary') : o;
-module.exports = {
-  encrypt,
-  decrypt
-};

package/lib/auth/ecc/src/brain_key.js

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.normalize = normalize;
-function normalize(brain_key) {
-  if (typeof brain_key !== 'string') {
-    throw new Error("string required for brain_key");
-  }
-  brain_key = brain_key.trim();
-  return brain_key.split(/[\t\n\v\f\r ]+/).join(' ');
-}