@bitpay-labs/bitcore-wallet-service 11.8.1 → 11.9.0

package/src/lib/routes/setup.ts

@@ -0,0 +1,86 @@
+import compression from 'compression';
+import express from 'express';
+import RateLimit from 'express-rate-limit';
+import config from '../../config';
+import { Common } from '../common';
+import { logger, transports } from '../logger';
+import { WalletService } from '../server';
+import { LogMiddleware } from './middleware/log';
+
+const Defaults = Common.Defaults;
+
+export function setupAppMiddleware(app: express.Express, opts) {
+  app.use(compression());
+
+  app.use((req, res, next) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, DELETE');
+    res.setHeader(
+      'Access-Control-Allow-Headers',
+      'x-signature,x-identity,x-identities,x-session,x-client-version,x-wallet-id,X-Requested-With,Content-Type,Authorization'
+    );
+    res.setHeader('x-service-version', WalletService.getServiceVersion());
+    next();
+  });
+
+  app.use((req, res, next) => {
+    if ('OPTIONS' == req.method) {
+      res.sendStatus(200);
+      res.end();
+      return;
+    }
+    next();
+  });
+
+  app.enable('trust proxy');
+
+  app.use((req, res, next) => {
+    req.on('abort', () => {
+      logger.warn('Request aborted by the client');
+    });
+    next();
+  });
+
+  const POST_LIMIT = 1024 * 100;
+  const POST_LIMIT_LARGE = 2 * 1024 * 1024;
+
+  app.use((req, res, next) => {
+    if (req.path.includes('/txproposals') || req.path.includes('/tss/')) {
+      return express.json({ limit: POST_LIMIT_LARGE })(req, res, next);
+    } else {
+      return express.json({ limit: POST_LIMIT })(req, res, next);
+    }
+  });
+
+  app.use((req, res, next) => {
+    if (config.maintenanceOpts.maintenanceMode === true) {
+      const errorCode = 503;
+      const errorMessage = 'BWS down for maintenance';
+      res.status(503).send({ code: errorCode, message: errorMessage });
+    } else {
+      next();
+    }
+  });
+
+  if (opts.disableLogs) {
+    for (const transport of transports) {
+      transport.level = 'error';
+    }
+  } else {
+    app.use(LogMiddleware());
+  }
+}
+
+export function createEstimateFeeLimiter(opts) {
+  if (Defaults.RateLimit.estimateFee && !opts.ignoreRateLimiter) {
+    logger.info(
+      'Limiting estimate fee per IP: %o req/h',
+      ((Defaults.RateLimit.estimateFee.max / Defaults.RateLimit.estimateFee.windowMs) * 60 * 60 * 1000).toFixed(2)
+    );
+    return new RateLimit(Defaults.RateLimit.estimateFee);
+  }
+
+  return (req, res, next) => {
+    next();
+  };
+}

package/src/lib/routes/transactions.ts

@@ -0,0 +1,196 @@
+import express from 'express';
+import { Errors } from '../errors/errordefinitions';
+import type * as Types from '../../types/expressapp';
+
+interface RouteContext {
+  getServerWithAuth: Types.GetServerWithAuthFn;
+  returnError: Types.ReturnErrorFn;
+}
+
+export function registerTransactionRoutes(router: express.Router, context: RouteContext) {
+  const { getServerWithAuth, returnError } = context;
+
+  router.get('/v1/txproposals/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server.getPendingTxs({ noCashAddr: true }, (err, pendings) => {
+        if (err) return returnError(err, res, req);
+        res.json(pendings);
+      });
+    });
+  });
+
+  router.get('/v2/txproposals/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server.getPendingTxs({}, (err, pendings) => {
+        if (err) return returnError(err, res, req);
+        res.json(pendings);
+      });
+    });
+  });
+
+  router.post('/v1/txproposals/', (req, res) => {
+    return returnError(Errors.UPGRADE_NEEDED, res, req);
+  });
+
+  router.post('/v2/txproposals/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.noCashAddr = true;
+      req.body.txpVersion = 3;
+      server.createTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+      });
+    });
+  });
+
+  router.post('/v3/txproposals/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txpVersion = 3;
+      server.createTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+      });
+    });
+  });
+
+  router.post('/v1/txproposals/:id/signatures/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.maxTxpVersion = 3;
+      req.body.txProposalId = req.params['id'];
+      server.signTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+        res.end();
+      });
+    });
+  });
+
+  router.post('/v2/txproposals/:id/signatures/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      req.body.maxTxpVersion = 3;
+      req.body.supportBchSchnorr = true;
+      server.signTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+        res.end();
+      });
+    });
+  });
+
+  router.post('/v1/txproposals/:id/prepare/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      server.prepareTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+        res.end();
+      });
+    });
+  });
+
+  router.post('/v1/txproposals/:id/publish/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      req.body.noCashAddr = true;
+      server.publishTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+        res.end();
+      });
+    });
+  });
+
+  router.post('/v2/txproposals/:id/publish/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      server.publishTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+        res.end();
+      });
+    });
+  });
+
+  router.post('/v1/txproposals/:id/broadcast/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      server.broadcastTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+        res.end();
+      });
+    });
+  });
+
+  router.post('/v1/txproposals/:id/rejections', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      server.rejectTx(req.body, (err, txp) => {
+        if (err) return returnError(err, res, req);
+        res.json(txp);
+        res.end();
+      });
+    });
+  });
+
+  router.delete('/v1/txproposals/:id/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      server.removePendingTx(req.body, err => {
+        if (err) return returnError(err, res, req);
+        res.json({ success: true });
+        res.end();
+      });
+    });
+  });
+
+  router.get('/v1/txproposals/:id/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txProposalId = req.params['id'];
+      server.getTx(req.body, (err, tx) => {
+        if (err) return returnError(err, res, req);
+        res.json(tx);
+        res.end();
+      });
+    });
+  });
+
+  router.get('/v1/txproposalsbyhash/:id/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      req.body.txid = req.params['id'];
+      server.getTxByHash(req.body, (err, tx) => {
+        if (err) return returnError(err, res, req);
+        res.json(tx);
+        res.end();
+      });
+    });
+  });
+
+  router.get('/v1/txhistory/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      const opts: {
+        skip?: number;
+        limit?: number;
+        reverse?: boolean;
+        includeExtendedInfo?: boolean;
+        tokenAddress?: string;
+        multisigContractAddress?: string;
+      } = {};
+      if (req.query.skip) opts.skip = +req.query.skip;
+      if (req.query.limit) opts.limit = +req.query.limit;
+      if (req.query.reverse == '1') opts.reverse = true;
+      if (req.query.tokenAddress) opts.tokenAddress = req.query.tokenAddress as string;
+      if (req.query.multisigContractAddress) {
+        opts.multisigContractAddress = req.query.multisigContractAddress as string;
+      }
+      if (req.query.includeExtendedInfo == '1') opts.includeExtendedInfo = true;
+
+      server.getTxHistory(opts, (err, txs) => {
+        if (err) return returnError(err, res, req);
+        res.json(txs);
+        res.end();
+      });
+    });
+  });
+}

package/src/lib/routes/walletdata.ts

@@ -0,0 +1,166 @@
+import express from 'express';
+import { Common } from '../common';
+import type * as Types from '../../types/expressapp';
+import type { GetAddressesOpts } from '../../types/server';
+
+const Utils = Common.Utils;
+
+interface RouteContext {
+  getServerWithAuth: Types.GetServerWithAuthFn;
+  logDeprecated: Types.LogDeprecatedFn;
+  returnError: Types.ReturnErrorFn;
+}
+
+export function registerWalletDataRoutes(router: express.Router, context: RouteContext) {
+  const { getServerWithAuth, logDeprecated, returnError } = context;
+
+  router.post('/v1/addresses/', (req, res) => {
+    logDeprecated(req);
+    getServerWithAuth(req, res, server => {
+      server.createAddress(
+        {
+          ignoreMaxGap: true
+        },
+        (err, address) => {
+          if (err) return returnError(err, res, req);
+          res.json(address);
+        }
+      );
+    });
+  });
+
+  router.post('/v2/addresses/', (req, res) => {
+    logDeprecated(req);
+    getServerWithAuth(req, res, server => {
+      server.createAddress(
+        {
+          ignoreMaxGap: true
+        },
+        (err, address) => {
+          if (err) return returnError(err, res, req);
+          res.json(address);
+        }
+      );
+    });
+  });
+
+  router.post('/v3/addresses/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      let opts = req.body;
+      opts = opts || {};
+      opts.noCashAddr = true;
+      server.createAddress(opts, (err, address) => {
+        if (err) return returnError(err, res, req);
+        res.json(address);
+      });
+    });
+  });
+
+  router.post('/v4/addresses/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server.createAddress(req.body, (err, address) => {
+        if (err) return returnError(err, res, req);
+        res.json(address);
+      });
+    });
+  });
+
+  router.get('/v1/addresses/', (req, res) => {
+    logDeprecated(req);
+    req.query.noChange = req.query.noChange ?? '1';
+    req.redirectedUrl = req.url;
+    req.url = '/v2/addresses?' + Object.entries(req.query).map(([key, value]) => `${key}=${value}`).join('&');
+    router.handle(req, res);
+  });
+
+  router.get('/v2/addresses/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      const opts: GetAddressesOpts = {};
+      if (req.query.limit) opts.limit = +req.query.limit;
+      if (req.query.skip) opts.skip = +req.query.skip;
+      opts.reverse = req.query.reverse == '1';
+      if (req.query.addresses) {
+        opts.addresses = Array.isArray(req.query.addresses) ? req.query.addresses : req.query.addresses.split(',');
+      }
+      opts.noChange = Utils.castToBool(req.query.noChange);
+
+      server.getAddresses(opts, (err, addresses) => {
+        if (err) return returnError(err, res, req);
+        res.json(addresses);
+      });
+    });
+  });
+
+  router.get('/v1/balance/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      const opts: { coin?: string; twoStep?: boolean; tokenAddress?: string; multisigContractAddress?: string } = {};
+      if (req.query.coin) opts.coin = req.query.coin as string;
+      if (req.query.twoStep == '1') opts.twoStep = true;
+      if (req.query.tokenAddress) opts.tokenAddress = req.query.tokenAddress as string;
+      if (req.query.multisigContractAddress) {
+        opts.multisigContractAddress = req.query.multisigContractAddress as string;
+      }
+
+      server.getBalance(opts, (err, balance) => {
+        if (err) return returnError(err, res, req);
+        res.json(balance);
+      });
+    });
+  });
+
+  router.get('/v1/sendmaxinfo/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      const query = req.query;
+      const opts: {
+        feePerKb?: number;
+        feeLevel?: number;
+        returnInputs?: boolean;
+        excludeUnconfirmedUtxos?: boolean;
+      } = {};
+      if (query.feePerKb) opts.feePerKb = +query.feePerKb;
+      if (query.feeLevel) opts.feeLevel = Number(query.feeLevel);
+      if (query.excludeUnconfirmedUtxos == '1') opts.excludeUnconfirmedUtxos = true;
+      if (query.returnInputs == '1') opts.returnInputs = true;
+
+      server.getSendMaxInfo(opts, (err, info) => {
+        if (err) return returnError(err, res, req);
+        res.json(info);
+      });
+    });
+  });
+
+  router.get('/v1/utxos/', (req, res) => {
+    const opts: { addresses?: string[] } = {};
+    const addresses = req.query.addresses;
+    if (addresses && typeof addresses === 'string') {
+      opts.addresses = (req.query.addresses as string).split(',');
+    }
+
+    getServerWithAuth(req, res, server => {
+      server.getUtxos(opts, (err, utxos) => {
+        if (err) return returnError(err, res, req);
+        res.json(utxos);
+      });
+    });
+  });
+
+  router.get('/v1/txcoins/', (req, res) => {
+    const txId = req.query.txId;
+    getServerWithAuth(req, res, server => {
+      server.getCoinsForTx({ txId }, (err, coins) => {
+        if (err) return returnError(err, res, req);
+        res.json(coins);
+      });
+    });
+  });
+
+  router.post('/v1/broadcast_raw/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server.broadcastRawTx(req.body, (err, txid) => {
+        if (err) return returnError(err, res, req);
+        res.json(txid);
+        res.end();
+      });
+    });
+  });
+}