@steemit/steem-js 0.8.0 → 1.0.1

package/docker-webpack.config.js

@@ -1,44 +0,0 @@
-const path = require('path');
-const webpack = require('webpack');
-
-module.exports = {
-  mode: 'production',
-  devtool: 'source-map',
-  entry: {
-    steem: path.resolve(__dirname, 'src/browser.js'),
-  },
-  output: {
-    path: path.resolve(__dirname, 'dist'),
-    filename: '[name].min.js',
-  },
-  resolve: {
-    alias: {
-      '@exodus/bytebuffer': 'bytebuffer',
-    }
-  },
-  node: {
-    stream: true,
-    crypto: 'empty',
-    path: 'empty',
-    fs: 'empty'
-  },
-  module: {
-    rules: [
-      {
-        test: /\.js?$/,
-        use: 'babel-loader',
-        exclude: /node_modules/,
-      },
-      {
-        test: /\.json?$/,
-        use: 'json-loader'
-      },
-    ],
-  },
-  plugins: [
-    new webpack.optimize.AggressiveMergingPlugin()
-  ],
-  optimization: {
-    minimize: true,
-  }
-}; 

package/lib/api/index.js

@@ -1,315 +0,0 @@
-"use strict";
-
-var _events = _interopRequireDefault(require("events"));
-var _bluebird = _interopRequireDefault(require("bluebird"));
-var _config = _interopRequireDefault(require("../config"));
-var _methods = _interopRequireDefault(require("./methods"));
-var _transports = _interopRequireDefault(require("./transports"));
-var _utils = require("../utils");
-var _ecc = require("../auth/ecc");
-var _serializer = require("../auth/serializer");
-var _http = require("./transports/http");
-var _rpcAuth = require("./rpc-auth");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class Steem extends _events.default {
-  constructor(options = {}) {
-    super(options);
-    this._setTransport(options);
-    this._setLogger(options);
-    this.options = options;
-    this.seqNo = 0; // used for rpc calls
-    _methods.default.forEach(method => {
-      const methodName = method.method_name || (0, _utils.camelCase)(method.method);
-      const methodParams = method.params || [];
-      this[`${methodName}With`] = (options, callback) => {
-        let params;
-        if (!method.is_object) {
-          params = methodParams.map(param => options[param]);
-        } else {
-          params = options;
-        }
-        return this.send(method.api, {
-          method: method.method,
-          params: params
-        }, callback);
-      };
-      this[methodName] = (...args) => {
-        const options = methodParams.reduce((memo, param, i) => {
-          memo[param] = args[i]; // eslint-disable-line no-param-reassign
-          return memo;
-        }, {});
-        const callback = args[methodParams.length];
-        return this[`${methodName}With`](options, callback);
-      };
-      this[`${methodName}WithAsync`] = _bluebird.default.promisify(this[`${methodName}With`]);
-      this[`${methodName}Async`] = _bluebird.default.promisify(this[methodName]);
-    });
-    this.callAsync = _bluebird.default.promisify(this.call);
-    this.signedCallAsync = _bluebird.default.promisify(this.signedCall);
-  }
-  _setTransport(options) {
-    if (options.url && options.url.match('^((http|https)?:\/\/)')) {
-      options.uri = options.url;
-      options.transport = 'http';
-      this._transportType = options.transport;
-      this.options = options;
-      this.transport = new _transports.default.http(options);
-    } else if (options.url && options.url.match('^((ws|wss)?:\/\/)')) {
-      options.websocket = options.url;
-      options.transport = 'ws';
-      this._transportType = options.transport;
-      this.options = options;
-      this.transport = new _transports.default.ws(options);
-    } else if (options.transport) {
-      if (this.transport && this._transportType !== options.transport) {
-        this.transport.stop();
-      }
-      this._transportType = options.transport;
-      if (typeof options.transport === 'string') {
-        if (!_transports.default[options.transport]) {
-          throw new TypeError('Invalid `transport`, valid values are `http`, `ws` or a class');
-        }
-        this.transport = new _transports.default[options.transport](options);
-      } else {
-        this.transport = new options.transport(options);
-      }
-    } else {
-      this.transport = new _transports.default.ws(options);
-    }
-  }
-  _setLogger(options) {
-    if (options.hasOwnProperty('logger')) {
-      switch (typeof options.logger) {
-        case 'function':
-          this.__logger = {
-            log: options.logger
-          };
-          break;
-        case 'object':
-          if (typeof options.logger.log !== 'function') {
-            throw new Error('setOptions({logger:{}}) must have a property .log of type function');
-          }
-          this.__logger = options.logger;
-          break;
-        case 'undefined':
-          if (this.__logger) break;
-        default:
-          this.__logger = false;
-      }
-    }
-  }
-  log(logLevel) {
-    if (this.__logger) {
-      if (arguments.length > 1 && typeof this.__logger[logLevel] === 'function') {
-        let args = Array.prototype.slice.call(arguments, 1);
-        this.__logger[logLevel].apply(this.__logger, args);
-      } else {
-        this.__logger.log.apply(this.__logger, arguments);
-      }
-    }
-  }
-  start() {
-    return this.transport.start();
-  }
-  stop() {
-    return this.transport.stop();
-  }
-  send(api, data, callback) {
-    var cb = callback;
-    if (this.__logger) {
-      let id = Math.random();
-      let self = this;
-      this.log('xmit:' + id + ':', data);
-      cb = function (e, d) {
-        if (e) {
-          self.log('error', 'rsp:' + id + ':\n\n', e, d);
-        } else {
-          self.log('rsp:' + id + ':', d);
-        }
-        if (callback) {
-          callback.apply(self, arguments);
-        }
-      };
-    }
-    return this.transport.send(api, data, cb);
-  }
-  call(method, params, callback) {
-    if (this._transportType !== 'http') {
-      callback(new Error('RPC methods can only be called when using http transport'));
-      return;
-    }
-    const id = ++this.seqNo;
-    (0, _http.jsonRpc)(this.options.uri, {
-      method,
-      params,
-      id
-    }).then(res => {
-      callback(null, res);
-    }, err => {
-      callback(err);
-    });
-  }
-  signedCall(method, params, account, key, callback) {
-    if (this._transportType !== 'http') {
-      callback(new Error('RPC methods can only be called when using http transport'));
-      return;
-    }
-    const id = ++this.seqNo;
-    let request;
-    try {
-      request = (0, _rpcAuth.sign)({
-        method,
-        params,
-        id
-      }, account, [key]);
-    } catch (error) {
-      callback(error);
-      return;
-    }
-    (0, _http.jsonRpc)(this.options.uri, request).then(res => {
-      callback(null, res);
-    }, err => {
-      callback(err);
-    });
-  }
-  setOptions(options) {
-    Object.assign(this.options, options);
-    this._setLogger(options);
-    this._setTransport(options);
-    this.transport.setOptions(options);
-    if (options.hasOwnProperty('useTestNet')) {
-      _config.default.set('address_prefix', options.useTestNet ? 'TST' : 'STM');
-    }
-  }
-  setWebSocket(url) {
-    this.setOptions({
-      websocket: url
-    });
-  }
-  setUri(url) {
-    this.setOptions({
-      uri: url
-    });
-  }
-  streamBlockNumber(mode = 'head', callback, ts = 200) {
-    if (typeof mode === 'function') {
-      callback = mode;
-      mode = 'head';
-    }
-    let current = '';
-    let running = true;
-    const update = () => {
-      if (!running) return;
-      this.getDynamicGlobalPropertiesAsync().then(result => {
-        const blockId = mode === 'irreversible' ? result.last_irreversible_block_num : result.head_block_number;
-        if (blockId !== current) {
-          if (current) {
-            for (let i = current; i < blockId; i++) {
-              if (i !== current) {
-                callback(null, i);
-              }
-              current = i;
-            }
-          } else {
-            current = blockId;
-            callback(null, blockId);
-          }
-        }
-        _bluebird.default.delay(ts).then(() => {
-          update();
-        });
-      }, err => {
-        callback(err);
-      });
-    };
-    update();
-    return () => {
-      running = false;
-    };
-  }
-  streamBlock(mode = 'head', callback) {
-    if (typeof mode === 'function') {
-      callback = mode;
-      mode = 'head';
-    }
-    let current = '';
-    let last = '';
-    const release = this.streamBlockNumber(mode, (err, id) => {
-      if (err) {
-        release();
-        callback(err);
-        return;
-      }
-      current = id;
-      if (current !== last) {
-        last = current;
-        this.getBlock(current, callback);
-      }
-    });
-    return release;
-  }
-  streamTransactions(mode = 'head', callback) {
-    if (typeof mode === 'function') {
-      callback = mode;
-      mode = 'head';
-    }
-    const release = this.streamBlock(mode, (err, result) => {
-      if (err) {
-        release();
-        callback(err);
-        return;
-      }
-      if (result && result.transactions) {
-        result.transactions.forEach(transaction => {
-          callback(null, transaction);
-        });
-      }
-    });
-    return release;
-  }
-  streamOperations(mode = 'head', callback) {
-    if (typeof mode === 'function') {
-      callback = mode;
-      mode = 'head';
-    }
-    const release = this.streamTransactions(mode, (err, transaction) => {
-      if (err) {
-        release();
-        callback(err);
-        return;
-      }
-      transaction.operations.forEach(operation => {
-        callback(null, operation);
-      });
-    });
-    return release;
-  }
-  broadcastTransactionSynchronousWith(options, callback) {
-    const trx = options.trx;
-    return this.send('network_broadcast_api', {
-      method: 'broadcast_transaction_synchronous',
-      params: [trx]
-    }, (err, result) => {
-      if (err) {
-        const {
-          signed_transaction
-        } = _serializer.ops;
-        // console.log('-- broadcastTransactionSynchronous -->', JSON.stringify(signed_transaction.toObject(trx), null, 2));
-        // toObject converts objects into serializable types
-        const trObject = signed_transaction.toObject(trx);
-        const buf = signed_transaction.toBuffer(trx);
-        err.digest = _ecc.hash.sha256(buf).toString('hex');
-        err.transaction_id = buf.toString('hex');
-        err.transaction = JSON.stringify(trObject);
-        callback(err, '');
-      } else {
-        callback('', result);
-      }
-    });
-  }
-}
-
-// Export singleton instance
-const steem = new Steem(_config.default);
-exports = module.exports = steem;
-exports.Steem = Steem;