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

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,167 @@
+import express from 'express';
+import * as _ from 'lodash';
+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 && _.isString(addresses)) {
+      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();
+      });
+    });
+  });
+}

package/src/lib/routes/wallets.ts

@@ -0,0 +1,289 @@
+import * as async from 'async';
+import express from 'express';
+import * as _ from 'lodash';
+import { Common } from '../common';
+import { ClientError } from '../errors/clienterror';
+import logger from '../logger';
+import { WalletService } from '../server';
+import type * as Types from '../../types/expressapp';
+
+const { Utils } = Common;
+
+interface RouteContext {
+  createWalletLimiter: Types.CreateWalletLimiterFn;
+  getServer: Types.GetServerFn;
+  getServerWithAuth: Types.GetServerWithAuthFn;
+  getServerWithMultiAuth: Types.GetServerWithMultiAuthFn;
+  logDeprecated: Types.LogDeprecatedFn;
+  returnError: Types.ReturnErrorFn;
+}
+
+function getServerOrReturnError(req, res, context: RouteContext): WalletService | null {
+  try {
+    return context.getServer(req, res);
+  } catch (err) {
+    context.returnError(err, res, req);
+    return null;
+  }
+}
+
+export function registerWalletRoutes(router: express.Router, context: RouteContext) {
+  const { createWalletLimiter, getServerWithAuth, getServerWithMultiAuth, logDeprecated, returnError } = context;
+
+  router.post('/v1/wallets/', createWalletLimiter, (req, res) => {
+    logDeprecated(req);
+    return returnError(new ClientError('BIP45 wallet creation no longer supported'), res, req);
+  });
+
+  router.post('/v2/wallets/', createWalletLimiter, (req, res) => {
+    const server = getServerOrReturnError(req, res, context);
+    if (!server) return;
+
+    server.createWallet(req.body, (err, walletId) => {
+      if (err) return returnError(err, res, req);
+      res.json({ walletId });
+    });
+  });
+
+  router.put('/v1/copayers/:id/', (req, res) => {
+    req.body.copayerId = req.params['id'];
+    const server = getServerOrReturnError(req, res, context);
+    if (!server) return;
+
+    server.addAccess(req.body, (err, result) => {
+      if (err) return returnError(err, res, req);
+      res.json(result);
+    });
+  });
+
+  router.post('/v1/wallets/:id/copayers/', (req, res) => {
+    logDeprecated(req);
+    return returnError(new ClientError('BIP45 wallet creation no longer supported'), res, req);
+  });
+
+  router.post('/v2/wallets/:id/copayers/', (req, res) => {
+    req.body.walletId = req.params['id'];
+    const server = getServerOrReturnError(req, res, context);
+    if (!server) return;
+
+    server.joinWallet(req.body, (err, result) => {
+      if (err) return returnError(err, res, req);
+      res.json(result);
+    });
+  });
+
+  router.get('/v1/wallets/', (req, res) => {
+    logDeprecated(req);
+    getServerWithAuth(req, res, server => {
+      server.getStatus({ includeExtendedInfo: true }, (err, status) => {
+        if (err) return returnError(err, res, req);
+        res.json(status);
+      });
+    });
+  });
+
+  router.get('/v2/wallets/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      const opts = { includeExtendedInfo: false, twoStep: false };
+      if (req.query.includeExtendedInfo == '1') opts.includeExtendedInfo = true;
+      if (req.query.twoStep == '1') opts.twoStep = true;
+
+      server.getStatus(opts, (err, status) => {
+        if (err) return returnError(err, res, req);
+        res.json(status);
+      });
+    });
+  });
+
+  router.get('/v3/wallets/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      const opts = {
+        includeExtendedInfo: false,
+        twoStep: false,
+        includeServerMessages: false,
+        tokenAddress: req.query.tokenAddress,
+        multisigContractAddress: req.query.multisigContractAddress,
+        network: req.query.network
+      };
+      if (req.query.includeExtendedInfo == '1') opts.includeExtendedInfo = true;
+      if (req.query.twoStep == '1') opts.twoStep = true;
+      if (req.query.serverMessageArray == '1') opts.includeServerMessages = true;
+
+      server.getStatus(opts, (err, status) => {
+        if (err) return returnError(err, res, req);
+        res.json(status);
+      });
+    });
+  });
+
+  router.get('/v1/wallets/all/', async (req, res) => {
+    let responses;
+    const includeExtendedInfo = req.query.includeExtendedInfo == '1';
+    const twoStep = req.query.twoStep == '1';
+    const silentFailure = req.query.silentFailure == '1';
+    const includeServerMessages = req.query.serverMessageArray == '1';
+
+    const buildOpts = (request, copayerId) => {
+      const getParam = (param, returnArray = false) => {
+        const value = request.query[`${copayerId}:${param}`] || request.query[copayerId]?.[param];
+        if (returnArray) {
+          return Array.isArray(value) ? value : value ? [value] : null;
+        }
+        return value ? value : null;
+      };
+
+      return {
+        includeExtendedInfo,
+        twoStep,
+        silentFailure,
+        includeServerMessages,
+        tokenAddresses: getParam('tokenAddress', true) as string[] | null,
+        multisigContractAddress: getParam('multisigContractAddress') as string | null,
+        network: getParam('network') as string | null
+      };
+    };
+
+    try {
+      responses = await Promise.all(
+        getServerWithMultiAuth(req, res, { silentFailure }).map(promise =>
+          promise
+            .then(
+              (server: WalletService) =>
+                new Promise(resolve => {
+                  const options = buildOpts(req, server.copayerId);
+                  if (options.tokenAddresses) {
+                    options.tokenAddresses.unshift(null);
+                    return async.concat(
+                      options.tokenAddresses,
+                      (tokenAddress, cb) => {
+                        const optsClone = JSON.parse(JSON.stringify(options));
+                        optsClone.tokenAddresses = null;
+                        optsClone.tokenAddress = tokenAddress;
+                        return server.getStatus(optsClone, (err, status) => {
+                          const result = {
+                            walletId: server.walletId,
+                            tokenAddress: optsClone.tokenAddress,
+                            success: true,
+                            ...(err ? { success: false, message: err.message } : {}),
+                            status
+                          };
+                          if (err && err.message) {
+                            logger.error(
+                              `An error occurred retrieving wallet status - id: ${server.walletId} - token address: ${optsClone.tokenAddress} - err: ${err.message}`
+                            );
+                          }
+                          cb(null, [result]);
+                        });
+                      },
+                      (_err, result) => resolve(result)
+                    );
+                  }
+
+                  return server.getStatus(options, (err, status) => {
+                    return resolve([
+                      {
+                        walletId: server.walletId,
+                        tokenAddress: null,
+                        success: true,
+                        ...(err ? { success: false, message: err.message } : {}),
+                        status
+                      }
+                    ]);
+                  });
+                }),
+              ({ message }) => Promise.resolve({ success: false, error: message })
+            )
+            .catch(err => {
+              if (silentFailure) {
+                return [];
+              }
+              returnError(err, res, req);
+              throw err;
+            })
+        )
+      );
+    } catch (err) {
+      if (res.headersSent) {
+        return;
+      }
+      return returnError(err, res, req);
+    }
+
+    if (res.headersSent) {
+      return;
+    }
+    return res.json(_.flatten(responses));
+  });
+
+  router.post('/v1/wallets/exist', async (req, res) => {
+    try {
+      const copayers = req.body.copayers;
+      if (!copayers || !Array.isArray(copayers)) {
+        logger.info('Invalid request to /v1/wallets/exist - copayers should be an array');
+        return res.json([]);
+      }
+
+      const storage = WalletService.getStorage();
+      const existing = await Promise.all<{ copayerId: string; verified: boolean }>(copayers.map(c => new Promise((resolve) => {
+        storage.fetchCopayerLookup(c.copayerId, (err, copayer) => {
+          if (err || !copayer) {
+            return resolve({ copayerId: c.copayerId, verified: false });
+          }
+          const verified = copayer.requestPubKeys.some(pubkey => Utils.verifyMessage(c.copayerId, c.signature, pubkey.key));
+          return resolve({ copayerId: c.copayerId, verified });
+        });
+      })));
+      return res.json(existing.filter(e => e.verified).map(e => e.copayerId));
+    } catch (err) {
+      return returnError(err, res, req);
+    }
+  });
+
+  router.get('/v1/wallets/:identifier/', (req, res) => {
+    getServerWithAuth(
+      req,
+      res,
+      {
+        onlySupportStaff: true
+      },
+      server => {
+        const opts = {
+          identifier: req.params['identifier'],
+          walletCheck: ['1', 'true'].includes(req.query['walletCheck'])
+        };
+
+        server.getWalletFromIdentifier(opts, (err, wallet) => {
+          if (err) return returnError(err, res, req);
+          if (!wallet) return res.end();
+
+          server.walletId = wallet.id;
+          const statusOpts = { includeExtendedInfo: false };
+          if (req.query.includeExtendedInfo == '1') statusOpts.includeExtendedInfo = true;
+
+          server.getStatus(statusOpts, (statusErr, status) => {
+            if (statusErr) return returnError(statusErr, res, req);
+            res.json(status);
+          });
+        });
+      }
+    );
+  });
+
+  router.get('/v1/preferences/', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server.getPreferences({}, (err, preferences) => {
+        if (err) return returnError(err, res, req);
+        res.json(preferences);
+      });
+    });
+  });
+
+  router.put('/v1/preferences', (req, res) => {
+    getServerWithAuth(req, res, server => {
+      server.savePreferences(req.body, (err, result) => {
+        if (err) return returnError(err, res, req);
+        res.json(result);
+      });
+    });
+  });
+}