@bitpay-labs/bitcore-wallet-service 11.11.0 → 11.11.2

package/src/lib/chain/eth/index.ts

@@ -1,4 +1,5 @@
-import { Transactions, Utils, Validation, Web3 } from '@bitpay-labs/crypto-wallet-core';
+import util from 'util';
+import { Constants as CWCConstants, Transactions, Utils, Validation, Web3 } from '@bitpay-labs/crypto-wallet-core';
 import _ from 'lodash';
 import { IWallet } from 'src/lib/model';
 import { IAddress } from 'src/lib/model/address';
@@ -23,6 +24,9 @@ function requireUncached(module) {
   return require(module);
 }
 
+// the effect type bitcore-node gives ERC20 transfers in tx events
+const ERC20_TRANSFER_EFFECT = 'ERC20:transfer';
+
 const Erc20Decoder = requireUncached('abi-decoder');
 Erc20Decoder.addABI(ERC20Abi);
 
@@ -118,7 +122,7 @@ export class EthChain implements IChain {
         // TODO support big int
         const lockedSum = Number(amounts + fees) || 0;  // previously set to 0 if opts.multisigContractAddress
         const convertedBalance = this.convertBitcoreBalance(balance, lockedSum);
-        server.storage.fetchAddresses(server.walletId, (err, addresses: IAddress[]) => {
+        server.storage.fetchAddressesPage(server.walletId, { limit: 1 }, (err, addresses: IAddress[]) => {
           if (err) return cb(err);
           if (addresses.length > 0) {
             const byAddress = [
@@ -170,121 +174,134 @@ export class EthChain implements IChain {
 
   checkScriptOutput(_output) { }
 
-  getFee(server, wallet, opts) {
-    return new Promise(resolve => {
-      server._getFeePerKb(wallet, opts, async (err, inFeePerKb) => {
-        let feePerKb = inFeePerKb;
-        let gasPrice = inFeePerKb;
-        let maxGasFee;
-        let priorityGasFee;
-        const { from, txType, priorityFeePercentile, gasLimitBuffer } = opts;
-        const { coin, network, chain } = wallet;
-        let inGasLimit = 0; // Per recepient gas limit
-        let gasLimit = 0; // Gas limit for all recepients. used for contract interactions that rollup recepients
-        let fee = 0;
-        const defaultGasLimit = this.getDefaultGasLimit(opts);
-        const outputAddresses = []; // Parameter for MuliSend contract
-        const outputAmounts: bigint[] = []; // Parameter for MuliSend contract
-        let totalValue = 0n; // Parameter for MuliSend contract
-        logger.info(`getFee for address ${from} on network ${network} and chain ${chain}`);
-        logger.info('getFee.opts: %o', { from, txType, priorityFeePercentile, gasLimitBuffer });
-        logger.info(`[${from}] Add gas limit buffer?: ${!!gasLimitBuffer}`);
-        for (const output of opts.outputs) {
-          // Multisend txs build contract fn parameters (addresses, amounts) and bypass output level gas estimations
-          if (opts.multiSendContractAddress) {
-            outputAddresses.push(output.toAddress);
-            outputAmounts.push(BigInt(output.amount));
-            if (!opts.tokenAddress) {
-              totalValue += BigInt(output.amount);
-            }
-            // Used as a fallback value if estimateGas fails for multisend
-            inGasLimit += output.gasLimit ? output.gasLimit : defaultGasLimit;
-            continue;
-          }
-          // Estimate a standard transfer
-          if (!output.gasLimit) {
-            try {
-              const to = opts.payProUrl
-                ? output.toAddress
-                : opts.tokenAddress
-                  ? opts.tokenAddress
-                  : opts.multisigContractAddress
-                    ? opts.multisigContractAddress
-                    : output.toAddress;
-              const value = opts.tokenAddress || opts.multisigContractAddress ? 0 : output.amount;
-              // output.gasLimit used as the gasLimit in getBitcoreTx for non multisend transactions
-              const gasLimitEstimate = await server.estimateGas({
-                coin,
-                chain: this.chain,
-                network,
-                from,
-                to,
-                value,
-                data: output.data,
-                gasPrice
-              });
-              output.gasLimit = gasLimitEstimate || defaultGasLimit;
-            } catch {
-              output.gasLimit = defaultGasLimit;
-            }
-          }
-          inGasLimit += output.gasLimit;
-          logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output level gas limit: ${output.gasLimit}`);
-          // Add gas Limit buffer to output level gasLimit
-          if (gasLimitBuffer) {
-            const gasBuffer = Math.ceil(output.gasLimit * (gasLimitBuffer / 100));
-            output.gasLimit += gasBuffer;
-            inGasLimit += gasBuffer;
-            logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output gas limit with buffer: ${output.gasLimit}`);
-          }
-          if (_.isNumber(opts.fee)) {
-            // This is used for sendmax
-            gasPrice = feePerKb = Number((opts.fee / (inGasLimit || defaultGasLimit)).toFixed());
-          }
-          fee += feePerKb * output.gasLimit;
-        }
-        // gasLimit == sum of internal gasLimits (for non Multisend)
-        gasLimit = inGasLimit;
-        logger.info(`[${from}] Current top level gas limit: ${gasLimit}`);
-        if (opts.multiSendContractAddress) {
-          // Calculate gas limit for top level of txp based on multisend tx
-          let _gasLimit;
-          try {
-            const data = this.encodeContractParameters(
-              Constants.BITPAY_CONTRACTS.MULTISEND,
-              { addresses: outputAddresses, amounts: outputAmounts },
-              opts
-            );
-
-            _gasLimit = await server.estimateGas({
-              coin,
-              chain: this.chain,
-              network,
-              from,
-              to: opts.multiSendContractAddress,
-              value: totalValue.toString(),
-              data,
-              gasPrice
-            });
-            logger.info(`[${from}] Estimated multisend gas limit: ${_gasLimit}`);
-          } catch (error) {
-            logger.error('Error estimating gas for MultiSend contract: %o', error);
-          }
-          // Add gas limit buffer to top level gas limit
-          const buffer = gasLimitBuffer ? gasLimitBuffer / 100 : Defaults.MS_GAS_LIMIT_BUFFER_PERCENT;
-          // If gas estimation fails, fallback to sum of internal gasLimits
-          gasLimit = _gasLimit || gasLimit;
-          gasLimit += Math.ceil(gasLimit * buffer); // add gas limit buffer 
-          fee += feePerKb * gasLimit;
-          logger.info(`[${from}] Top level gas limit with buffer: ${gasLimit}`);
+  async getFee(server, wallet, opts) {
+    const hasType2FeeOverride = opts.maxGasFee != null || opts.priorityGasFee != null;
+    let { maxGasFee, priorityGasFee } = opts;
+    if (hasType2FeeOverride) {
+      const chain = wallet.chain || wallet.coin;
+      // Keep overrides consistent with CWC's chain-specific minimum priority fee.
+      const minimum = CWCConstants.FEE_MINIMUMS[chain.toUpperCase()]?.priority ?? 0;
+      if (priorityGasFee < minimum) {
+        throw new ClientError(`priorityGasFee must be at least ${minimum} wei for ${chain}`);
+      }
+    }
+    // Use the explicit rate for both construction and the fee reserved from the wallet balance.
+    const feeOpts = opts.gasPrice != null || hasType2FeeOverride
+      ? { ...opts, feePerKb: opts.gasPrice ?? maxGasFee }
+      : opts;
+    // Fixed fees are converted to a gas price below, once the gas limits are known.
+    const fixedFee = Common.Utils.isNumber(opts.fee) ? Number(opts.fee) : undefined;
+    const inFeePerKb = fixedFee != null
+      ? undefined
+      : await util.promisify(server._getFeePerKb).call(server, wallet, feeOpts);
+    let feePerKb = inFeePerKb;
+    let gasPrice = inFeePerKb;
+    const { from, txType, priorityFeePercentile, gasLimitBuffer } = opts;
+    const { coin, network, chain } = wallet;
+    let inGasLimit = 0; // Per recepient gas limit
+    let gasLimit = 0; // Gas limit for all recepients. used for contract interactions that rollup recepients
+    let fee = 0;
+    const defaultGasLimit = this.getDefaultGasLimit(opts);
+    const outputAddresses = []; // Parameter for MuliSend contract
+    const outputAmounts: bigint[] = []; // Parameter for MuliSend contract
+    let totalValue = 0n; // Parameter for MuliSend contract
+    logger.info(`getFee for address ${from} on network ${network} and chain ${chain}`);
+    logger.info('getFee.opts: %o', { from, txType, priorityFeePercentile, gasLimitBuffer });
+    logger.info(`[${from}] Add gas limit buffer?: ${!!gasLimitBuffer}`);
+    for (const output of opts.outputs) {
+      // Multisend txs build contract fn parameters (addresses, amounts) and bypass output level gas estimations
+      if (opts.multiSendContractAddress) {
+        outputAddresses.push(output.toAddress);
+        outputAmounts.push(BigInt(output.amount));
+        if (!opts.tokenAddress) {
+          totalValue += BigInt(output.amount);
         }
-        if (Number(txType) === 2) {
-          maxGasFee = await server.estimateFee({ network, chain: wallet.chain || coin, txType: 2 });
-          priorityGasFee = await server.estimatePriorityFee({ network, chain: wallet.chain || coin, percentile: priorityFeePercentile || 15 });
+        // Used as a fallback value if estimateGas fails for multisend
+        inGasLimit += output.gasLimit ? output.gasLimit : defaultGasLimit;
+        continue;
+      }
+      // Estimate a standard transfer
+      if (!output.gasLimit) {
+        try {
+          const to = opts.payProUrl
+            ? output.toAddress
+            : opts.tokenAddress
+              ? opts.tokenAddress
+              : opts.multisigContractAddress
+                ? opts.multisigContractAddress
+                : output.toAddress;
+          const value = opts.tokenAddress || opts.multisigContractAddress ? 0 : output.amount;
+          // output.gasLimit used as the gasLimit in getBitcoreTx for non multisend transactions
+          const gasLimitEstimate = await server.estimateGas({
+            coin,
+            chain: this.chain,
+            network,
+            from,
+            to,
+            value,
+            data: output.data,
+            gasPrice
+          });
+          output.gasLimit = gasLimitEstimate || defaultGasLimit;
+        } catch {
+          output.gasLimit = defaultGasLimit;
         }
-        return resolve({ feePerKb, gasPrice, gasLimit, maxGasFee, priorityGasFee, fee });
-      });
-    });
+      }
+      inGasLimit += output.gasLimit;
+      logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output level gas limit: ${output.gasLimit}`);
+      // Add gas Limit buffer to output level gasLimit
+      if (gasLimitBuffer) {
+        const gasBuffer = Math.ceil(output.gasLimit * (gasLimitBuffer / 100));
+        output.gasLimit += gasBuffer;
+        inGasLimit += gasBuffer;
+        logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output gas limit with buffer: ${output.gasLimit}`);
+      }
+      if (fixedFee != null) {
+        // This is used for sendmax
+        gasPrice = feePerKb = Number((fixedFee / (inGasLimit || defaultGasLimit)).toFixed());
+      }
+      fee += feePerKb * output.gasLimit;
+    }
+    // gasLimit == sum of internal gasLimits (for non Multisend)
+    gasLimit = inGasLimit;
+    logger.info(`[${from}] Current top level gas limit: ${gasLimit}`);
+    if (opts.multiSendContractAddress) {
+      // Calculate gas limit for top level of txp based on multisend tx
+      let _gasLimit;
+      try {
+        const data = this.encodeContractParameters(
+          Constants.BITPAY_CONTRACTS.MULTISEND,
+          { addresses: outputAddresses, amounts: outputAmounts },
+          opts
+        );
+
+        _gasLimit = await server.estimateGas({
+          coin,
+          chain: this.chain,
+          network,
+          from,
+          to: opts.multiSendContractAddress,
+          value: totalValue.toString(),
+          data,
+          gasPrice
+        });
+        logger.info(`[${from}] Estimated multisend gas limit: ${_gasLimit}`);
+      } catch (error) {
+        logger.error('Error estimating gas for MultiSend contract: %o', error);
+      }
+      // Add gas limit buffer to top level gas limit
+      const buffer = gasLimitBuffer ? gasLimitBuffer / 100 : Defaults.MS_GAS_LIMIT_BUFFER_PERCENT;
+      // If gas estimation fails, fallback to sum of internal gasLimits
+      gasLimit = _gasLimit || gasLimit;
+      gasLimit += Math.ceil(gasLimit * buffer); // add gas limit buffer
+      fee += feePerKb * gasLimit;
+      logger.info(`[${from}] Top level gas limit with buffer: ${gasLimit}`);
+    }
+    if (Number(txType) === 2 && !hasType2FeeOverride) {
+      maxGasFee = await server.estimateFee({ network, chain: wallet.chain || coin, txType: 2 });
+      priorityGasFee = await server.estimatePriorityFee({ network, chain: wallet.chain || coin, percentile: priorityFeePercentile || 15 });
+    }
+    return { feePerKb, gasPrice, gasLimit, maxGasFee, priorityGasFee, fee };
   }
 
   isPrePublishRawBound(txp: TxProposal) {
@@ -613,7 +630,7 @@ export class EthChain implements IChain {
     if (tx.effects && tx.effects.length) {
       const multisigConfirm = tx.effects.findIndex(e => e.type === 'MULTISIG:confirmTransaction');
       const multisigSubmit = tx.effects.findIndex(e => e.type === 'MULTISIG:submitTransaction');
-      const erc20Transfer = tx.effects.findIndex(e => e.type === 'ERC20:transer');
+      const erc20Transfer = tx.effects.findIndex(e => e.type === ERC20_TRANSFER_EFFECT);
       const internalTransfer = tx.effects.findIndex(e => !e.type && !e.contractAddress);
 
       const exists = [multisigConfirm, multisigSubmit, erc20Transfer, internalTransfer].filter(i => i > -1);
@@ -625,7 +642,7 @@ export class EthChain implements IChain {
           multisigContractAddress = best.contractAddress;
           address = best.to;
           amount = best.amount;
-        } else if (best.type == 'ERC20:transfer') {
+        } else if (best.type == ERC20_TRANSFER_EFFECT) {
           tokenAddress = best.contractAddress;
           address = best.to;
           amount = best.amount;

package/src/lib/chain/sol/index.ts

@@ -73,7 +73,7 @@ export class SolChain implements IChain {
           const lockedSum = Number(amounts + fees) || 0;  // previously set to 0 if opts.multisigContractAddress
           const reserveAmount = opts.tokenAddress ? 0 : reserve;
           const convertedBalance = this.convertBitcoreBalance(balance, lockedSum, reserveAmount);
-          server.storage.fetchAddresses(server.walletId, (err, addresses: IAddress[]) => {
+          server.storage.fetchAddressesPage(server.walletId, { limit: 1 }, (err, addresses: IAddress[]) => {
             if (err) return cb(err);
             if (addresses.length > 0) {
               const byAddress = [

package/src/lib/chain/xrp/index.ts

@@ -69,7 +69,7 @@ export class XrpChain implements IChain {
             return sum + BigInt(txp.amount || 0) + BigInt(txp.fee || 0);
           }, 0n) || 0n;
           const convertedBalance = this.convertBitcoreBalance(balance, Number(lockedSum), reserve);
-          server.storage.fetchAddresses(server.walletId, (err, addresses: IAddress[]) => {
+          server.storage.fetchAddressesPage(server.walletId, { limit: 1 }, (err, addresses: IAddress[]) => {
             if (err) return cb(err);
             if (addresses.length > 0) {
               const byAddress = [

package/src/lib/routes/services.ts

@@ -459,18 +459,6 @@ export function registerServiceRoutes(router: express.Router, context: RouteCont
     });
   });
 
-  router.post('/v1/service/wyre/walletOrderQuotation', (req, res) => {
-    respondWithAuthServer(req, res, context, server => {
-      return server.externalServices.wyre.wyreWalletOrderQuotation(req);
-    });
-  });
-
-  router.post('/v1/service/wyre/walletOrderReservation', (req, res) => {
-    respondWithAuthServer(req, res, context, server => {
-      return server.externalServices.wyre.wyreWalletOrderReservation(req);
-    });
-  });
-
   router.post('/v1/service/changelly/getCurrencies', (req, res) => {
     respondWithPublicServer(req, res, context, server => {
       return server.externalServices.changelly.changellyGetCurrencies(req);

package/src/lib/routes/wallets.ts

@@ -228,8 +228,10 @@ export function registerWalletRoutes(router: express.Router, context: RouteConte
         return res.json([]);
       }
 
+      // a copayer that isn't an object with a string id can't exist, so it isn't looked up
+      const wellFormed = copayers.filter(c => typeof c?.copayerId === 'string');
       const storage = WalletService.getStorage();
-      const existing = await Promise.all<{ copayerId: string; verified: boolean }>(copayers.map(async c => {
+      const existing = await Promise.all<{ copayerId: string; verified: boolean }>(wellFormed.map(async c => {
         const copayer = await storage.fetchCopayerLookup(c.copayerId).catch(() => null);
         if (!copayer) {
           return { copayerId: c.copayerId, verified: false };