@bitpay-labs/bitcore-wallet-service 11.5.2

package/src/lib/chain/index.ts

@@ -0,0 +1,178 @@
+import { IChain } from '../../types/chain';
+import { Common } from '../common';
+import { IWallet, TxProposal } from '../model';
+import { WalletService } from '../server';
+import logger from './../logger';
+import { ArbChain } from './arb';
+import { BaseChain } from './base';
+import { BchChain } from './bch';
+import { BtcChain } from './btc';
+import { DogeChain } from './doge';
+import { EthChain } from './eth';
+import { LtcChain } from './ltc';
+import { MaticChain } from './matic';
+import { OpChain } from './op';
+import { SolChain } from './sol';
+import { XrpChain } from './xrp';
+
+const Constants = Common.Constants;
+const Defaults = Common.Defaults;
+
+const chains: { [chain: string]: IChain } = {
+  BTC: new BtcChain(),
+  BCH: new BchChain(),
+  ETH: new EthChain(),
+  MATIC: new MaticChain(),
+  ARB: new ArbChain(),
+  BASE: new BaseChain(),
+  OP: new OpChain(),
+  XRP: new XrpChain(),
+  DOGE: new DogeChain(),
+  LTC: new LtcChain(),
+  SOL: new SolChain()
+};
+
+class ChainProxy {
+  get(chain: string) {
+    const normalizedChain = chain.toUpperCase();
+    return chains[normalizedChain];
+  }
+
+  /**
+   * @deprecated
+   */
+  getChain(coin: string): string {
+    try {
+      if (coin === undefined) { // This happens frequently for very old btc wallets/addresses
+        return Defaults.CHAIN;
+      }
+      // TODO add a warning that we are not including chain
+      let normalizedChain = coin.toLowerCase();
+      if (
+        Constants.BITPAY_SUPPORTED_ETH_ERC20[normalizedChain.toUpperCase()] ||
+        !Constants.CHAINS[normalizedChain.toUpperCase()]
+      ) {
+        // default to eth if it's an ETH ERC20 or if we don't know the chain
+        normalizedChain = 'eth';
+      }
+      return normalizedChain;
+    } catch (err) {
+      logger.error(`Error getting chain for coin ${coin}: %o`, err.stack || err.message || err);
+      return Defaults.CHAIN; // coin should always exist but most unit test don't have it -> return btc as default
+    }
+  }
+
+  getWalletBalance(server, wallet, opts, cb) {
+    return this.get(wallet.chain).getWalletBalance(server, wallet, opts, cb);
+  }
+
+  getWalletSendMaxInfo(server, wallet, opts, cb) {
+    return this.get(wallet.chain).getWalletSendMaxInfo(server, wallet, opts, cb);
+  }
+
+  getDustAmountValue(chain) {
+    return this.get(chain).getDustAmountValue();
+  }
+
+  getTransactionCount(server, wallet, from) {
+    return this.get(wallet.chain).getTransactionCount(server, wallet, from);
+  }
+
+  getChangeAddress(server, wallet, opts) {
+    return this.get(wallet.chain).getChangeAddress(server, wallet, opts);
+  }
+
+  checkDust(chain, output, opts) {
+    return this.get(chain).checkDust(output, opts);
+  }
+
+  checkScriptOutput(chain, output) {
+    return this.get(chain).checkScriptOutput(output);
+  }
+
+  getFee(server, wallet, opts) {
+    return this.get(wallet.chain).getFee(server, wallet, opts);
+  }
+
+  getBitcoreTx(txp: TxProposal, opts = { signed: true }) {
+    return this.get(txp.chain).getBitcoreTx(txp, { signed: opts.signed });
+  }
+
+  convertFeePerKb(chain, p, feePerKb) {
+    return this.get(chain).convertFeePerKb(p, feePerKb);
+  }
+
+  addressToStorageTransform(chain, network, address) {
+    return this.get(chain).addressToStorageTransform(network, address);
+  }
+
+  addressFromStorageTransform(chain, network, address) {
+    return this.get(chain).addressFromStorageTransform(network, address);
+  }
+
+  checkTx(server, txp) {
+    return this.get(txp.chain).checkTx(server, txp);
+  }
+
+  checkTxUTXOs(server, txp, opts, cb) {
+    return this.get(txp.chain).checkTxUTXOs(server, txp, opts, cb);
+  }
+
+  selectTxInputs(server, txp, wallet, opts, cb) {
+    return this.get(txp.chain).selectTxInputs(server, txp, wallet, opts, cb);
+  }
+
+  checkUtxos(chain, opts) {
+    return this.get(chain).checkUtxos(opts);
+  }
+
+  checkValidTxAmount(chain: string, output): boolean {
+    return this.get(chain).checkValidTxAmount(output);
+  }
+
+  isUTXOChain(chain: string): boolean {
+    return this.get(chain).isUTXOChain();
+  }
+
+  isSingleAddress(chain: string): boolean {
+    return this.get(chain).isSingleAddress();
+  }
+
+  notifyConfirmations(chain: string, network: string): boolean {
+    return this.get(chain).notifyConfirmations(network);
+  }
+
+  supportsMultisig(chain: string): boolean {
+    return this.get(chain).supportsMultisig();
+  }
+
+  supportsThresholdsig(chain: string): boolean {
+    return this.get(chain).supportsThresholdsig();
+  }
+
+  addSignaturesToBitcoreTx(chain, tx, inputs, inputPaths, signatures, xpub, signingMethod) {
+    this.get(chain).addSignaturesToBitcoreTx(tx, inputs, inputPaths, signatures, xpub, signingMethod);
+  }
+
+  validateAddress(wallet, inaddr, opts) {
+    return this.get(wallet.chain).validateAddress(wallet, inaddr, opts);
+  }
+
+  onCoin(chain: string, coinData: any) {
+    return this.get(chain).onCoin(coinData);
+  }
+
+  onTx(chain: string, tx: any) {
+    return this.get(chain).onTx(tx);
+  }
+
+  getReserve(server: WalletService, wallet: IWallet, cb: (err?, reserve?: number) => void) {
+    return this.get(wallet.chain).getReserve(server, wallet, cb);
+  }
+
+  refreshTxData(server, txp, opts, cb) {
+    return this.get(txp.chain).refreshTxData(server, txp, opts, cb);
+  }
+}
+
+export const ChainService = new ChainProxy();

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

@@ -0,0 +1,9 @@
+import { BitcoreLibLtc } from '@bitpay-labs/crypto-wallet-core';
+import { IChain } from '../../../types/chain';
+import { BtcChain } from '../../chain/btc';
+
+export class LtcChain extends BtcChain implements IChain {
+  constructor() {
+    super(BitcoreLibLtc);
+  }
+}

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

@@ -0,0 +1,8 @@
+import { EthChain } from '../eth';
+
+export class MaticChain extends EthChain {
+  constructor() {
+    super();
+    this.chain = 'MATIC';
+  }
+}

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

@@ -0,0 +1,8 @@
+import { EthChain } from '../eth';
+
+export class OpChain extends EthChain {
+  constructor() {
+    super();
+    this.chain = 'OP';
+  }
+}

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

@@ -0,0 +1,349 @@
+import { Transactions, Utils, Validation } from '@bitpay-labs/crypto-wallet-core';
+import _ from 'lodash';
+import { IChain } from '../../../types/chain';
+import { WalletWithOpts } from '../../blockchainexplorers/v8';
+import { Defaults } from '../../common/defaults';
+import { Errors } from '../../errors/errordefinitions';
+import logger from '../../logger';
+import { IWallet, TxProposal, Wallet } from '../../model';
+import { IAddress } from '../../model/address';
+import { WalletService } from '../../server';
+
+export class SolChain implements IChain {
+  chain: string;
+
+  constructor() {
+    this.chain = 'SOL';
+  }
+
+  private convertBitcoreBalance(bitcoreBalance, locked, minRent = Defaults.MIN_SOL_BALANCE) {
+    const { confirmed, balance } = bitcoreBalance;
+    let activatedLocked = locked;
+  
+    if (balance > 0) {
+      activatedLocked = locked + minRent;
+    }
+    const convertedBalance = {
+      totalAmount: balance,
+      totalConfirmedAmount: confirmed,
+      lockedAmount: activatedLocked,
+      lockedConfirmedAmount: activatedLocked,
+      availableAmount: balance - activatedLocked,
+      availableConfirmedAmount: confirmed - activatedLocked,
+      byAddress: []
+    };
+    return convertedBalance;
+  }
+
+  getWalletBalance(server: WalletService, wallet: Wallet, opts: { tokenAddress?: string }, cb) {
+    const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
+
+    if (opts.tokenAddress) {
+      (wallet as WalletWithOpts).tokenAddress = opts.tokenAddress;
+    }
+
+    bc.getBalance(wallet as WalletWithOpts, (err, balance) => {
+      if (err) {
+        return cb(err);
+      }
+      bc.getRentMinimum(null, (err, reserve) => {
+        if (err) {
+          return cb(err);
+        }
+        // getPendingTxs returns all txps when given a native currency
+        server.getPendingTxs(opts, (err, txps) => {
+          if (err) return cb(err);
+          const { fees, amounts } = txps.reduce((acc, txp) => {
+            // Add gas used for tokens when getting native balance
+            if (!opts.tokenAddress) {
+              acc.fees += txp.fee || 0;
+            }
+            
+            // Filter tokens when getting native balance
+            if (!(txp.tokenAddress && !opts.tokenAddress)) {
+              acc.amounts += txp.amount;
+            }
+            
+            return acc;
+          }, { fees: 0, amounts: 0 });
+
+          const lockedSum = (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[]) => {
+            if (err) return cb(err);
+            if (addresses.length > 0) {
+              const byAddress = [
+                {
+                  address: addresses[0].address,
+                  path: addresses[0].path,
+                  amount: convertedBalance.totalAmount
+                }
+              ];
+              convertedBalance.byAddress = byAddress;
+            }
+            return cb(null, convertedBalance);
+          });
+        });
+      });
+    });
+  }
+
+  getFee(server, wallet, opts) {
+    return new Promise(resolve => {
+      const numSignatures = opts.numSignatures || 1;
+      const feePerKb = Defaults.SOL_BASE_FEE; // Fee per signature in lamports
+      const fee = feePerKb * numSignatures;
+      return resolve({ fee, feePerKb });
+    });
+  }
+
+  getBitcoreTx(txp, opts = { signed: true }) {
+    const {
+      data,
+      outputs,
+      payProUrl,
+      tokenAddress,
+      isTokenSwap,
+      multiTx
+    } = txp;
+    if (multiTx) {
+      throw Errors.MULTI_TX_UNSUPPORTED;
+    }
+    const isSPL = tokenAddress && !payProUrl && !isTokenSwap;
+    const chain = isSPL ? `${this.chain}SPL` : this.chain;
+    const recipients = outputs.map(output => {
+      return {
+        amount: output.amount,
+        address: output.toAddress,
+        data: output.data
+      };
+    });
+    if (data) {
+      recipients[0].data = data;
+    }
+
+    const unsignedTxs = [Transactions.create({ ...txp, chain, recipients })];
+    const tx = {
+      uncheckedSerialize: () => unsignedTxs,
+      txid: () => txp.txid,
+      toObject: () => {
+        const ret = _.clone(txp);
+        ret.outputs[0].satoshis = ret.outputs[0].amount;
+        return ret;
+      },
+      getFee: () => {
+        return txp.fee;
+      },
+      getChangeOutput: () => null
+    };
+
+    if (opts.signed) {
+      const sigs = txp.getCurrentSignatures();
+      for (const x of sigs) {
+        this.addSignaturesToBitcoreTx(tx, txp.inputs, txp.inputPaths, x.signatures, x.xpub);
+      } 
+    }
+
+    return tx;
+  }
+
+  addSignaturesToBitcoreTx(tx, _inputs, _inputPaths, signatures, _xpub) {
+    if (signatures.length === 0) {
+      throw new Error('Signatures Required');
+    }
+
+    const unsignedTxs = tx.uncheckedSerialize();
+    const signedTxs = [];
+    for (let index = 0; index < signatures.length; index++) {
+      const signed = Transactions.applySignature({
+        chain: this.chain,
+        tx: unsignedTxs[index],
+        signature: signatures[index]
+      }); // expected to be in raw string format
+      signedTxs.push(signed);
+      tx.id = Transactions.getHash({ tx: signed, chain: this.chain });
+    }
+    tx.uncheckedSerialize = () => signedTxs;
+  }
+
+  getTransactionCount(server, wallet, from) {
+    return new Promise((resolve, reject) => {
+      server._getTransactionCount(wallet, from, (err, count) => {
+        if (err) return reject(err);
+        return resolve(count);
+      });
+    });
+  }
+
+  getWalletSendMaxInfo(server: WalletService, wallet, opts, cb) {
+    server.getBalance({}, (err, balance) => {
+      if (err) return cb(err);
+      const { availableAmount } = balance;
+      const sigs = opts.numSignatures || 1;
+      const fee = sigs * Defaults.SOL_BASE_FEE;
+      return cb(null, {
+        utxosBelowFee: 0,
+        amountBelowFee: 0,
+        amount: availableAmount - fee,
+        feePerKb: opts.feePerKb,
+        fee
+      });
+    });
+  }
+
+  checkValidTxAmount(output): boolean {
+    try {
+      if (
+        output.amount == null ||
+        output.amount < 0 ||
+        isNaN(output.amount) ||
+        Utils.toHex(output.amount) !== '0x' + BigInt(output.amount).toString(16)
+      ) {
+        logger.warn('output.amount is not a valid value: ' + output.amount);
+        return false;
+      }
+      return true;
+    } catch (err) {
+      logger.warn(`Invalid output amount (${output.amount}) in checkValidTxAmount: %o`, err);
+      return false;
+    }
+  }
+
+  checkTx(txp) {
+    try {
+      this.getBitcoreTx(txp);
+    } catch (ex) {
+      logger.debug('Error building Bitcore transaction: %o', ex);
+      return ex;
+    }
+
+    return null;
+  }
+
+  selectTxInputs(server: WalletService, txp: TxProposal, wallet: IWallet, opts: { tokenAddress?: string }, cb) {
+    server.getBalance({ wallet, tokenAddress: opts?.tokenAddress }, (err, balance) => {
+      if (err) return cb(err);
+      const { totalAmount, availableAmount } = balance;
+      // calculate how much space is needed to find rent amount
+      const minRentException = opts.tokenAddress ? 0 : Defaults.MIN_SOL_BALANCE;
+      if (totalAmount - minRentException < txp.getTotalAmount()) {
+        return cb(Errors.INSUFFICIENT_FUNDS);
+      } else if (availableAmount < txp.getTotalAmount()) {
+        return cb(Errors.LOCKED_FUNDS);
+      } else {
+        return cb(this.checkTx(txp));
+      }
+    });
+  }
+
+  validateAddress(wallet, inaddr, opts) {
+    const chain = this.chain.toLowerCase();
+    const isValidTo = Validation.validateAddress(chain, wallet.network, inaddr);
+    if (!isValidTo) {
+      throw Errors.INVALID_ADDRESS;
+    }
+    const isValidFrom = Validation.validateAddress(chain, wallet.network, opts.from);
+    if (!isValidFrom) {
+      throw Errors.INVALID_ADDRESS;
+    }
+    return;
+  }
+
+  addressFromStorageTransform(network, address): void {
+    if (network != 'livenet') {
+      const x = address.address.indexOf(':' + network);
+      if (x >= 0) {
+        address.address = address.address.substr(0, x);
+      }
+    }
+  }
+
+  addressToStorageTransform(network, address): void {
+    if (network != 'livenet') address.address += ':' + network;
+  }
+
+
+  getRentMinimum(server: WalletService, wallet: IWallet, space: number, cb: (err?, reserve?: number) => void) {
+    const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
+    bc.getRentMinimum(space, (err, reserve) => {
+      if (err) {
+        return cb(err);
+      }
+      return cb(null, reserve);
+    });
+  }
+
+  refreshTxData(server: WalletService, txp, _opts, cb) {
+    if ((txp.blockHeight || txp.blockHash) && txp.isRepublishEnabled()) {
+      server._getBlockchainHeight(txp.chain, txp.network, (err, height, hash) => {
+        if (err) return cb(err);
+        txp.blockHeight = height;
+        txp.blockHash = hash;
+        return cb(null, txp);
+      });
+    } else {
+      return cb(null, txp);
+    }
+  }
+
+  getReserve(server: WalletService, wallet: IWallet, cb: (err?, reserve?: number) => void) {
+    return cb(null, 0);
+  }
+
+  getSizeSafetyMargin() {
+    return 0;
+  }
+
+  getInputSizeSafetyMargin() {
+    return 0;
+  }
+
+  notifyConfirmations() {
+    return false;
+  }
+
+  supportsMultisig() {
+    return false;
+  }
+
+  supportsThresholdsig() {
+    return false; // TODO: need to add EDDSA support to bitcore-tss
+  }
+
+  isUTXOChain() {
+    return false;
+  }
+
+  isSingleAddress() {
+    return true;
+  }
+
+  getDustAmountValue() {
+    return 0;
+  }
+
+  getChangeAddress() { }
+
+  checkDust(_output, _opts) { }
+
+  checkScriptOutput(_output) { }
+
+  onCoin(_coin) {
+    return null;
+  }
+
+  convertFeePerKb(p, feePerKb) {
+    return [p, feePerKb];
+  }
+
+  checkTxUTXOs(server, txp, opts, cb) {
+    return cb();
+  }
+
+  checkUtxos(_opts) { }
+
+  onTx(_tx) {
+    return null;
+  }
+}