@bitpay-labs/bitcore-wallet-service 11.8.0 → 11.8.2

package/src/lib/logger.ts

@@ -1,77 +1,8 @@
-import path from 'path';
-import * as winston from 'winston';
+import { createLogger, formatTimestamp, timestamp } from '@bitpay-labs/bitcore-logging';
 
-// const logLevel = args.DEBUG ? 'debug' : 'info';
-const logLevel = process.env.BWS_LOG_LEVEL || 'debug';
-
-export const transports: winston.transport[] = [
-  new winston.transports.Console({
-    level: logLevel,
-    format: winston.format.combine(
-      winston.format.colorize(),
-      winston.format.prettyPrint(),
-      winston.format.splat(),
-      winston.format.simple(),
-      winston.format.printf(function(info) {
-        // fallback in case the above formatters don't work.
-        // eg: logger.log({ some: 'object' })
-        if (typeof info.message === 'object') {
-          info.message = JSON.stringify(info.message, null, 4);
-        }
-        return `${info.level} :: ${new Date().toISOString()} :: ${info.message}`;
-      })
-    ),
-  })
-];
-
-if (process.env.BWS_LOG_HTTP_HOST) {
-  transports.push(new winston.transports.Http({
-    level: process.env.BWS_LOG_HTTP_LEVEL || logLevel,
-    host: process.env.BWS_LOG_HTTP_HOST,
-    port: parseInt(process.env.BWS_LOG_HTTP_PORT) || undefined,
-    path: process.env.BWS_LOG_HTTP_PATH || ('bws.' + path.parse(process.argv[1]).name),
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    format: winston.format.combine(
-      winston.format.splat(),
-      winston.format.simple(),
-      winston.format.printf(info => {
-        // fallback in case the above formatters don't work.
-        // eg: logger.log({ some: 'object' })
-        if (typeof info.message === 'object') {
-          info.message = JSON.stringify(info.message, null, 4);
-        }
-        return JSON.stringify({
-          tag: process.env.BWS_LOG_HTTP_TAG || ('bws.' + path.parse(process.argv[1]).name),
-          ...info
-        });
-      }),
-    )
-  }));
-}
-
-export const logger = winston.createLogger({ transports });
-
-export const formatTimestamp = (date: Date): string =>
-  `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date
-    .getDate()
-    .toString()
-    .padStart(2, '0')} ${date
-    .getHours()
-    .toString()
-    .padStart(2, '0')}:${date
-    .getMinutes()
-    .toString()
-    .padStart(2, '0')}:${date
-    .getSeconds()
-    .toString()
-    .padStart(2, '0')}.${date
-    .getMilliseconds()
-    .toString()
-    // .padEnd(3, '0')} ${timezone}`;
-    .padEnd(3, '0')}`;
-
-export const timestamp = () => formatTimestamp(new Date());
+type BwsLogger = ReturnType<typeof createLogger>;
 
+export const logger: BwsLogger = createLogger({ prefix: 'BWS', defaultLevel: 'debug' });
+export const transports: BwsLogger['transports'] = logger.transports;
+export { formatTimestamp, timestamp };
 export default logger;

package/src/lib/model/txproposal.ts

@@ -424,16 +424,20 @@ export class TxProposal implements ITxProposal {
   }
 
   getCurrentSignatures() {
-    const acceptedActions = _.filter(this.actions, a => {
-      return a.type == 'accept';
-    });
-
-    return _.map(acceptedActions, x => {
-      return {
-        signatures: x.signatures,
-        xpub: x.xpub
-      };
-    });
+    const acceptedActions = this.actions.filter(a => a.type == 'accept');
+
+    const uniqueXpubs = new Set();
+    const signatures = [];
+    for (const a of acceptedActions) {
+      // TSS will have multiple accept actions with the same xpub/signature (different copayerIds)
+      if (uniqueXpubs.has(a.xpub)) continue;
+      uniqueXpubs.add(a.xpub);
+      signatures.push({
+        signatures: a.signatures,
+        xpub: a.xpub
+      });
+    }
+    return signatures;
   }
 
   getRawTx() {

package/src/lib/routes/advertisements.ts

@@ -0,0 +1,151 @@
+import express from 'express';
+import type * as Types from '../../types/expressapp';
+
+interface RouteContext {
+  getServer: Types.GetServerFn;
+  getServerWithAuth: Types.GetServerWithAuthFn;
+  setPublicCache: (res: express.Response, seconds: number) => void;
+  returnError: Types.ReturnErrorFn;
+}
+
+export function registerAdvertisementRoutes(router: express.Router, context: RouteContext) {
+  const { getServer, getServerWithAuth, setPublicCache, returnError } = context;
+  const ONE_MINUTE = 60;
+
+  router.post('/v1/advertisements/', (req, res) => {
+    getServerWithAuth(
+      req,
+      res,
+      {
+        onlyMarketingStaff: true
+      },
+      server => {
+        server.createAdvert(req.body, (err, advert) => {
+          if (err) {
+            return returnError(err, res, req);
+          }
+          if (advert) res.json(advert);
+        });
+      }
+    );
+  });
+
+  router.get('/v1/advertisements/', (req, res) => {
+    const testing = req.query.testing;
+
+    let server;
+    try {
+      server = getServer(req, res);
+    } catch (ex) {
+      return returnError(ex, res, req);
+    }
+
+    if (testing) {
+      server.getTestingAdverts(req.body, (err, ads) => {
+        if (err) return returnError(err, res, req);
+        res.json(ads);
+      });
+      return;
+    }
+
+    setPublicCache(res, 5 * ONE_MINUTE);
+    server.getAdverts(req.body, (err, ads) => {
+      if (err) return returnError(err, res, req);
+      res.json(ads);
+    });
+  });
+
+  router.get('/v1/advertisements/:adId/', (req, res) => {
+    let server;
+
+    try {
+      server = getServer(req, res);
+    } catch (ex) {
+      return returnError(ex, res, req);
+    }
+
+    const opts = { adId: req.params['adId'] };
+
+    if (req.params['adId']) {
+      server.getAdvert(opts, (err, ad) => {
+        if (err) return returnError(err, res, req);
+        res.json(ad);
+      });
+    }
+  });
+
+  router.get('/v1/advertisements/country/:country', (req, res) => {
+    const opts = { country: req.params['country'] };
+
+    let server;
+    try {
+      server = getServer(req, res);
+    } catch (ex) {
+      return returnError(ex, res, req);
+    }
+
+    server.getAdvertsByCountry(opts, (err, ads) => {
+      if (err) return returnError(err, res, req);
+      res.json(ads);
+    });
+  });
+
+  router.post('/v1/advertisements/:adId/activate', (req, res) => {
+    const opts = { adId: req.params['adId'] };
+
+    getServerWithAuth(
+      req,
+      res,
+      {
+        onlyMarketingStaff: true
+      },
+      server => {
+        if (req.params['adId']) {
+          server.activateAdvert(opts, err => {
+            if (err) return returnError(err, res, req);
+            res.json({ advertisementId: opts.adId, message: 'advert activated' });
+          });
+        }
+      }
+    );
+  });
+
+  router.post('/v1/advertisements/:adId/deactivate', (req, res) => {
+    const opts = { adId: req.params['adId'] };
+
+    getServerWithAuth(
+      req,
+      res,
+      {
+        onlyMarketingStaff: true
+      },
+      server => {
+        if (req.params['adId']) {
+          server.deactivateAdvert(opts, err => {
+            if (err) return returnError(err, res, req);
+            res.json({ advertisementId: opts.adId, message: 'advert deactivated' });
+          });
+        }
+      }
+    );
+  });
+
+  router.delete('/v1/advertisements/:adId/', (req, res) => {
+    getServerWithAuth(
+      req,
+      res,
+      {
+        onlyMarketingStaff: true
+      },
+      server => {
+        req.body.adId = req.params['adId'];
+        server.removeAdvert(req.body, (err, removedAd) => {
+          if (err) return returnError(err, res, req);
+          if (removedAd) {
+            res.json(removedAd);
+          }
+        });
+      }
+    );
+  });
+}

package/src/lib/routes/blockchain.ts

@@ -0,0 +1,152 @@
+import express from 'express';
+import * as _ from 'lodash';
+import type * as Types from '../../types/expressapp';
+import type { WalletService } from '../server';
+
+interface RouteContext {
+  estimateFeeLimiter: express.Handler;
+  getServer: Types.GetServerFn;
+  getServerWithAuth: Types.GetServerWithAuthFn;
+  logDeprecated: Types.LogDeprecatedFn;
+  setPublicCache: (res: express.Response, seconds: number) => void;
+  returnError: Types.ReturnErrorFn;
+}
+
+type RouteHandler = (server: WalletService) => Promise<any> | any;
+
+const ONE_MINUTE = 60;
+
+function callbackResult<T>(fn: (cb: (err?: any, data?: T) => void) => void): Promise<T> {
+  return new Promise((resolve, reject) => {
+    fn((err, data) => {
+      if (err) return reject(err);
+      return resolve(data as T);
+    });
+  });
+}
+
+function getServerOrReturnError(req, res, context: RouteContext): WalletService | null {
+  try {
+    return context.getServer(req, res);
+  } catch (err) {
+    context.returnError(err, res, req);
+    return null;
+  }
+}
+
+function respondWithPublicServer(req, res, context: RouteContext, handler: RouteHandler) {
+  const server = getServerOrReturnError(req, res, context);
+  if (!server) return;
+
+  Promise.resolve()
+    .then(() => handler(server))
+    .then(response => {
+      res.json(response);
+    })
+    .catch(err => {
+      context.returnError(err ?? 'unknown', res, req);
+    });
+}
+
+function respondWithAuthServer(req, res, context: RouteContext, handler: RouteHandler) {
+  context.getServerWithAuth(req, res, server => {
+    Promise.resolve()
+      .then(() => handler(server))
+      .then(response => {
+        res.json(response);
+      })
+      .catch(err => {
+        context.returnError(err ?? 'unknown', res, req);
+      });
+  });
+}
+
+export function registerBlockchainRoutes(router: express.Router, context: RouteContext) {
+  const { estimateFeeLimiter, logDeprecated, setPublicCache } = context;
+
+  router.get('/v1/feelevels/', estimateFeeLimiter, (req, res) => {
+    setPublicCache(res, 1 * ONE_MINUTE);
+    logDeprecated(req);
+
+    respondWithPublicServer(req, res, context, server =>
+      callbackResult(resolve => {
+        const opts: { network?: string } = {};
+        if (req.query.network) opts.network = req.query.network as string;
+        server.getFeeLevels(opts, resolve);
+      }).then((feeLevels: any[]) => {
+        _.each(feeLevels, feeLevel => {
+          feeLevel.feePerKB = feeLevel.feePerKb;
+          delete feeLevel.feePerKb;
+        });
+        return feeLevels;
+      })
+    );
+  });
+
+  router.get('/v2/feelevels/', (req, res) => {
+    setPublicCache(res, 1 * ONE_MINUTE);
+
+    respondWithPublicServer(req, res, context, server =>
+      callbackResult(resolve => {
+        const opts: { coin?: string; network?: string; chain?: string } = {};
+        if (req.query.coin) opts.coin = req.query.coin as string;
+        if (req.query.chain || req.query.coin) opts.chain = (req.query.chain || req.query.coin) as string;
+        if (req.query.network) opts.network = req.query.network as string;
+        server.getFeeLevels(opts, resolve);
+      })
+    );
+  });
+
+  router.post('/v3/estimateGas/', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.estimateGas(req.body);
+    });
+  });
+
+  router.post('/v1/ethmultisig/', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.getMultisigContractInstantiationInfo(req.body);
+    });
+  });
+
+  router.post('/v1/ethmultisig/info', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.getMultisigContractInfo(req.body);
+    });
+  });
+
+  router.post('/v1/multisig/', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.getMultisigContractInstantiationInfo(req.body);
+    });
+  });
+
+  router.post('/v1/multisig/info', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.getMultisigContractInfo(req.body);
+    });
+  });
+
+  router.post('/v1/token/info', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.getTokenContractInfo(req.body);
+    });
+  });
+
+  router.post('/v1/token/allowance', (req, res) => {
+    respondWithPublicServer(req, res, context, server => {
+      return server.getTokenAllowance(req.body);
+    });
+  });
+
+  router.get('/v1/nonce/:address', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.getNonce({
+        coin: req.query.coin || 'eth',
+        chain: req.query.chain,
+        network: req.query.network || 'livenet',
+        address: req.params['address']
+      });
+    });
+  });
+}

package/src/lib/routes/context.ts

@@ -0,0 +1,149 @@
+import express from 'express';
+import * as Types from '../../types/expressapp';
+import { Errors } from '../errors/errordefinitions';
+import { logger } from '../logger';
+import { WalletService } from '../server';
+
+interface RouteHelpers {
+  getServer: Types.GetServerFn;
+  getServerWithAuth: Types.GetServerWithAuthFn;
+  getServerWithMultiAuth: Types.GetServerWithMultiAuthFn;
+  logDeprecated: Types.LogDeprecatedFn;
+  setPublicCache: (res: express.Response, seconds: number) => void;
+}
+
+export function createRouteHelpers(returnError: Types.ReturnErrorFn): RouteHelpers {
+  const logDeprecated: Types.LogDeprecatedFn = req => {
+    logger.warn('DEPRECATED', req.method, req.url, '(' + req.header('x-client-version') + ')');
+  };
+
+  const getCredentials: Types.GetCredentialsFn = req => {
+    const identity = req.header('x-identity');
+    if (!identity) return;
+
+    return {
+      copayerId: identity,
+      signature: req.header('x-signature'),
+      session: req.header('x-session')
+    };
+  };
+
+  const getServer: Types.GetServerFn = (req, _res) => {
+    const opts = {
+      clientVersion: req.header('x-client-version'),
+      userAgent: req.header('user-agent')
+    };
+    return WalletService.getInstance(opts);
+  };
+
+  const getServerWithAuth: Types.GetServerWithAuthFn = async (req, res, opts, cb) => {
+    if (typeof opts === 'function') {
+      cb = opts;
+      opts = {};
+    }
+    opts = (opts || {}) as Types.ServerOpts;
+
+    const credentials = getCredentials(req);
+    if (!credentials) {
+      return returnError(Errors.NOT_AUTHORIZED, res, req);
+    }
+
+    const reqUrl = req.redirectedUrl || req.url;
+    const auth = {
+      copayerId: credentials.copayerId,
+      message: req.method.toLowerCase() + '|' + reqUrl + '|' + JSON.stringify(req.body),
+      signature: credentials.signature,
+      clientVersion: req.header('x-client-version'),
+      userAgent: req.header('user-agent'),
+      walletId: req.header('x-wallet-id'),
+      session: undefined
+    };
+
+    if (opts.allowSession) {
+      auth.session = credentials.session;
+    }
+
+    try {
+      const server: WalletService = await new Promise((resolve, reject) => {
+        WalletService.getInstanceWithAuth(auth, (err, server) => {
+          if (err) {
+            return reject(err);
+          }
+
+          if (opts.onlySupportStaff && !server.copayerIsSupportStaff) {
+            return reject(Errors.NOT_AUTHORIZED);
+          }
+
+          if (server.copayerIsSupportStaff) {
+            req.isSupportStaff = true;
+          }
+
+          if (opts.onlyMarketingStaff && !server.copayerIsMarketingStaff) {
+            return reject(Errors.NOT_AUTHORIZED);
+          }
+
+          req.walletId = server.walletId;
+          req.copayerId = server.copayerId;
+
+          return resolve(server);
+        });
+      });
+
+      if (cb) {
+        return cb(server);
+      }
+      return server;
+    } catch (err) {
+      if (opts.silentFailure) {
+        if (cb) {
+          return cb(null, err);
+        }
+        throw err;
+      }
+      return returnError(err, res, req);
+    }
+  };
+
+  const getServerWithMultiAuth: Types.GetServerWithMultiAuthFn = (req, res, opts = {}) => {
+    const identitiesHeader = req.headers['x-identities'];
+    const identitiesHeaderValue = Array.isArray(identitiesHeader) ? identitiesHeader.join(',') : identitiesHeader;
+    const identities = identitiesHeaderValue ? identitiesHeaderValue.split(',') : false;
+    const signature = req.headers['x-signature'];
+    if (!identities || !signature) {
+      throw Errors.NOT_AUTHORIZED;
+    }
+
+    if (!Array.isArray(identities)) {
+      throw Errors.NOT_AUTHORIZED;
+    }
+
+    return identities.map(
+      id =>
+        new Promise((resolve, reject) =>
+          getServerWithAuth(
+            Object.assign(req, {
+              headers: {
+                ...req.headers,
+                'x-identity': id
+              }
+            }),
+            res,
+            opts,
+            (server, err) => (err ? reject(err) : resolve(server))
+          )
+        )
+    );
+  };
+
+  const setPublicCache = (res: express.Response, seconds: number) => {
+    res.setHeader('Cache-Control', `public, max-age=${seconds}, stale-if-error=${10 * seconds}`);
+  };
+
+  return {
+    getServer,
+    getServerWithAuth,
+    getServerWithMultiAuth,
+    logDeprecated,
+    setPublicCache
+  };
+}

package/src/lib/routes/maintenance.ts

@@ -0,0 +1,111 @@
+import express from 'express';
+import * as _ from 'lodash';
+import { WalletService } from '../server';
+import { Stats } from '../stats';
+import type * as Types from '../../types/expressapp';
+
+interface RouteContext {
+  getServerWithAuth: Types.GetServerWithAuthFn;
+  setPublicCache: (res: express.Response, seconds: number) => void;
+  returnError: Types.ReturnErrorFn;
+}
+
+const ONE_MINUTE = 60;
+
+export function registerMaintenanceRoutes(router: express.Router, context: RouteContext) {
+  const { getServerWithAuth, setPublicCache, returnError } = context;
+
+  router.post('/v1/addresses/scan/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body = req.body || {};
+      req.body.startIdx = server.copayerIsSupportStaff ? Number(req.body.startIdx) : null;
+      server.startScan(req.body, (err, started) => {
+        if (err) return returnError(err, res, req);
+        res.json(started);
+        res.end();
+      });
+    });
+  });
+
+  router.get('/v1/stats/', (req, res) => {
+    setPublicCache(res, 1 * ONE_MINUTE);
+    const opts: {
+      network?: string;
+      coin?: string;
+      from?: string;
+      to?: string;
+    } = {};
+
+    if (req.query.network) opts.network = req.query.network as string;
+    if (req.query.coin) opts.coin = req.query.coin as string;
+    if (req.query.from) opts.from = req.query.from as string;
+    if (req.query.to) opts.to = req.query.to as string;
+
+    const stats = new Stats(opts);
+    stats.run((err, data) => {
+      if (err) return returnError(err, res, req);
+      res.json(data);
+      res.end();
+    });
+  });
+
+  router.get('/v1/version/', (req, res) => {
+    setPublicCache(res, 1 * ONE_MINUTE);
+    res.json({
+      serviceVersion: WalletService.getServiceVersion()
+    });
+    res.end();
+  });
+
+  router.get('/v1/txnotes/:txid', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server.getTxNote(
+        {
+          txid: req.params['txid']
+        },
+        (err, note) => {
+          if (err) return returnError(err, res, req);
+          res.json(note);
+        }
+      );
+    });
+  });
+
+  router.put('/v1/txnotes/:txid/', (req, res) => {
+    req.body.txid = req.params['txid'];
+    getServerWithAuth(req, res, server => {
+      server.editTxNote(req.body, (err, note) => {
+        if (err) return returnError(err, res, req);
+        res.json(note);
+      });
+    });
+  });
+
+  router.get('/v1/txnotes/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      const opts: { minTs?: number } = {};
+      if (req.query.minTs && _.isNumber(+req.query.minTs)) {
+        opts.minTs = +req.query.minTs;
+      }
+      server.getTxNotes(opts, (err, notes) => {
+        if (err) return returnError(err, res, req);
+        res.json(notes);
+      });
+    });
+  });
+
+  router.post('/v1/clearcache/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server
+        .clearWalletCache(req.query)
+        .then(val => {
+          if (val) {
+            res.sendStatus(200);
+          } else {
+            res.sendStatus(500);
+          }
+        })
+        .catch(err => returnError(err, res, req));
+    });
+  });
+}