@bitpay-labs/bitcore-wallet-service 11.5.2

package/src/lib/model/txproposal_legacy.ts

@@ -0,0 +1,236 @@
+import _ from 'lodash';
+import preconditions from 'preconditions';
+import { Common } from '../common';
+import logger from '../logger';
+import { TxProposalAction } from './txproposalaction';
+
+const $ = preconditions.singleton();
+
+const Constants = Common.Constants;
+const Defaults = Common.Defaults;
+
+function throwUnsupportedError() {
+  const msg = 'Unsupported operation on this transaction proposal';
+  logger.warn('DEPRECATED: ' + msg);
+  throw new Error(msg);
+}
+
+export interface ITxProposal {
+  version: string;
+  type: string;
+  createdOn: number;
+  id: number;
+  walletId: string;
+  creatorId: string;
+  outputs: any[];
+  toAddress: string;
+  amount: number;
+  message: string;
+  payProUrl: string;
+  proposalSignature: string;
+  changeAddress: string;
+  inputs: any[];
+  requiredSignatures: number;
+  requiredRejections: number;
+  walletN: number;
+  status: string;
+  txid: string;
+  broadcastedOn: string;
+  inputPaths: string;
+  actions: any[];
+  outputOrder: number;
+  coin: string;
+  network: string;
+  fee: number;
+  feePerKb: number;
+  excludeUnconfirmedUtxos: boolean;
+  proposalSignaturePubKey: string;
+  proposalSignaturePubKeySig: string;
+  addressType: string;
+  derivationStrategy: string;
+  customData: any;
+}
+export class TxProposalLegacy {
+  version: string;
+  type: string;
+  createdOn: number;
+  id: number;
+  walletId: string;
+  creatorId: string;
+  outputs: any[];
+  toAddress: string;
+  amount: number;
+  message: string;
+  payProUrl: string;
+  proposalSignature: string;
+  changeAddress: string;
+  inputs: any[];
+  requiredSignatures: number;
+  requiredRejections: number;
+  walletN: number;
+  status: string;
+  txid: string;
+  broadcastedOn: number;
+  inputPaths: string;
+  actions: any[];
+  outputOrder: number;
+  coin: string;
+  network: string;
+  fee: number;
+  feePerKb: number;
+  excludeUnconfirmedUtxos: boolean;
+  proposalSignaturePubKey: string;
+  proposalSignaturePubKeySig: string;
+  addressType: string;
+  derivationStrategy: string;
+  customData: any;
+
+  static Types = {
+    SIMPLE: 'simple',
+    MULTIPLEOUTPUTS: 'multiple_outputs',
+    EXTERNAL: 'external'
+  };
+
+  static fromObj(obj) {
+    const x = new TxProposalLegacy();
+
+    x.version = obj.version;
+    if (obj.version === '1.0.0') {
+      x.type = TxProposalLegacy.Types.SIMPLE;
+    } else {
+      x.type = obj.type;
+    }
+    x.createdOn = obj.createdOn;
+    x.id = obj.id;
+    x.walletId = obj.walletId;
+    x.creatorId = obj.creatorId;
+    x.outputs = obj.outputs;
+    x.toAddress = obj.toAddress;
+    x.amount = obj.amount;
+    x.message = obj.message;
+    x.payProUrl = obj.payProUrl;
+    x.proposalSignature = obj.proposalSignature;
+    x.changeAddress = obj.changeAddress;
+    x.inputs = obj.inputs;
+    x.requiredSignatures = obj.requiredSignatures;
+    x.requiredRejections = obj.requiredRejections;
+    x.walletN = obj.walletN;
+    x.status = obj.status;
+    x.txid = obj.txid;
+    x.broadcastedOn = obj.broadcastedOn;
+    x.inputPaths = obj.inputPaths;
+    x.actions = _.map(obj.actions, function(action) {
+      return TxProposalAction.fromObj(action);
+    });
+    x.outputOrder = obj.outputOrder;
+    x.coin = obj.coin || Defaults.COIN;
+    x.network = obj.network;
+    x.fee = obj.fee;
+    x.feePerKb = obj.feePerKb;
+    x.excludeUnconfirmedUtxos = obj.excludeUnconfirmedUtxos;
+    x.proposalSignaturePubKey = obj.proposalSignaturePubKey;
+    x.proposalSignaturePubKeySig = obj.proposalSignaturePubKeySig;
+    x.addressType = obj.addressType || Constants.SCRIPT_TYPES.P2SH;
+    x.derivationStrategy = obj.derivationStrategy || Constants.DERIVATION_STRATEGIES.BIP45;
+    x.customData = obj.customData;
+
+    return x;
+  }
+
+  toObject() {
+    const x: any = _.cloneDeep(this);
+    x.isPending = this.isPending();
+    return x;
+  }
+
+  _updateStatus() {
+    if (this.status != 'pending') return;
+
+    if (this.isRejected()) {
+      this.status = 'rejected';
+    } else if (this.isAccepted()) {
+      this.status = 'accepted';
+    }
+  }
+
+  getBitcoreTx() {
+    throwUnsupportedError();
+  }
+
+  getRawTx() {
+    throwUnsupportedError();
+  }
+
+  getTotalAmount() {
+    if (this.type == TxProposalLegacy.Types.MULTIPLEOUTPUTS || this.type == TxProposalLegacy.Types.EXTERNAL) {
+      return _.map(this.outputs, 'amount').reduce(function(total, n) {
+        return total + n;
+      }, 0);
+    } else {
+      return this.amount;
+    }
+  }
+
+  getActors() {
+    return _.map(this.actions, 'copayerId');
+  }
+
+  getApprovers() {
+    return _.map(
+      _.filter(this.actions, a => {
+        return a.type == 'accept';
+      }),
+      'copayerId'
+    );
+  }
+
+  getActionBy(copayerId) {
+    return _.find(this.actions, {
+      copayerId
+    });
+  }
+
+  addAction(copayerId, type, comment, signatures?, xpub?) {
+    const action = TxProposalAction.create({
+      copayerId,
+      type,
+      signatures,
+      xpub,
+      comment
+    });
+    this.actions.push(action);
+    this._updateStatus();
+  }
+
+  sign() {
+    throwUnsupportedError();
+  }
+
+  reject(copayerId, reason) {
+    this.addAction(copayerId, 'reject', reason);
+  }
+
+  isPending() {
+    return !['broadcasted', 'rejected'].includes(this.status);
+  }
+
+  isAccepted() {
+    const votes = _.countBy(this.actions, 'type');
+    return votes['accept'] >= this.requiredSignatures;
+  }
+
+  isRejected() {
+    const votes = _.countBy(this.actions, 'type');
+    return votes['reject'] >= this.requiredRejections;
+  }
+
+  isBroadcasted() {
+    return this.status == 'broadcasted';
+  }
+
+  setBroadcasted() {
+    $.checkState(this.txid, 'Failed state: this.txid at setBroadcasted()');
+    this.status = 'broadcasted';
+    this.broadcastedOn = Math.floor(Date.now() / 1000);
+  }
+}

package/src/lib/model/txproposalaction.ts

@@ -0,0 +1,48 @@
+export interface ITxProposalAction {
+  version: string;
+  createdOn: number;
+  copayerId: string;
+  type: string;
+  signatures: string[];
+  xpub: string;
+  comment: string;
+}
+export class TxProposalAction {
+  version: string;
+  createdOn: number;
+  copayerId: string;
+  type: string;
+  signatures: string[];
+  xpub: string;
+  comment: string;
+
+  static create(opts) {
+    opts = opts || {};
+
+    const x = new TxProposalAction();
+
+    x.version = '1.0.0';
+    x.createdOn = Math.floor(Date.now() / 1000);
+    x.copayerId = opts.copayerId;
+    x.type = opts.type;
+    x.signatures = opts.signatures;
+    x.xpub = opts.xpub;
+    x.comment = opts.comment;
+
+    return x;
+  }
+
+  static fromObj(obj) {
+    const x = new TxProposalAction();
+
+    x.version = obj.version;
+    x.createdOn = obj.createdOn;
+    x.copayerId = obj.copayerId;
+    x.type = obj.type;
+    x.signatures = obj.signatures;
+    x.xpub = obj.xpub;
+    x.comment = obj.comment;
+
+    return x;
+  }
+}

package/src/lib/model/wallet.ts

@@ -0,0 +1,359 @@
+import {
+  BitcoreLib,
+  BitcoreLibCash,
+  BitcoreLibDoge,
+  BitcoreLibLtc,
+} from '@bitpay-labs/crypto-wallet-core';
+import { singleton } from 'preconditions';
+import Uuid from 'uuid';
+import config from '../../config';
+import { Common } from '../common';
+import logger from '../logger';
+import { Address } from './address';
+import { AddressManager, IAddressManager } from './addressmanager';
+import { Copayer, ICopayer } from './copayer';
+
+const $ = singleton();
+const { Constants, Defaults, Utils } = Common;
+
+const Bitcore = {
+  btc: BitcoreLib,
+  bch: BitcoreLibCash,
+  eth: BitcoreLib,
+  matic: BitcoreLib,
+  arb: BitcoreLib,
+  base: BitcoreLib,
+  op: BitcoreLib,
+  xrp: BitcoreLib,
+  doge: BitcoreLibDoge,
+  ltc: BitcoreLibLtc,
+  sol: BitcoreLib,
+};
+
+export interface IWallet<isSharedT = boolean | (() => boolean)> {
+  version: string;
+  createdOn: number;
+  id: string;
+  name: string;
+  m: number;
+  n: number;
+  singleAddress: boolean;
+  status: string;
+  publicKeyRing: Array<{ xPubKey: string; requestPubKey: string }>;
+  hardwareSourcePublicKey?: string;
+  clientDerivedPublicKey?: string;
+  addressIndex: number;
+  copayers: Array<ICopayer>;
+  pubKey: string;
+  coin: string;
+  chain: string;
+  network: string;
+  derivationStrategy: string;
+  addressType: string;
+  addressManager: IAddressManager;
+  scanStatus?: 'error' | 'success' | 'running';
+  beRegistered: boolean; // Block explorer registered
+  beAuthPrivateKey2?: string;
+  beAuthPublicKey2?: string;
+  nativeCashAddr?: boolean;
+  isTestnet?: boolean;
+  usePurpose48?: boolean;
+  isShared?: isSharedT;
+  tssVersion?: number;
+  tssKeyId?: string;
+};
+
+export class Wallet implements IWallet<() => boolean> {
+  version: string;
+  createdOn: number;
+  id: string;
+  name: string;
+  m: number;
+  n: number;
+  singleAddress: boolean;
+  status: string;
+  publicKeyRing: Array<{ xPubKey: string; requestPubKey: string }>;
+  hardwareSourcePublicKey?: string;
+  clientDerivedPublicKey?: string;
+  addressIndex: number;
+  copayers: Array<Copayer>;
+  pubKey: string;
+  coin: string;
+  chain: string;
+  network: string;
+  derivationStrategy: string;
+  addressType: string;
+  addressManager: AddressManager;
+  scanStatus?: 'error' | 'success' | 'running';
+  beRegistered: boolean; // Block explorer registered
+  beAuthPrivateKey2?: string;
+  beAuthPublicKey2?: string;
+  nativeCashAddr?: boolean;
+  isTestnet?: boolean;
+  usePurpose48?: boolean;
+  scanning: boolean;
+  tssVersion: number;
+  tssKeyId: string;
+
+  static COPAYER_PAIR_LIMITS = {};
+
+  static create(opts: {
+    id: string;
+    name: string;
+    m: number;
+    n: number;
+    coin: string;
+    chain: string; // chain === coin for stored wallets
+    network: string;
+    pubKey: string;
+    singleAddress: boolean;
+    derivationStrategy: string;
+    addressType: string;
+    nativeCashAddr?: boolean;
+    usePurpose48?: boolean;
+    hardwareSourcePublicKey?: string;
+    clientDerivedPublicKey?: string;
+    tssVersion?: number;
+    tssKeyId?: string;
+  }) {
+    opts = opts || {} as any;
+
+    const chain = opts.chain || opts.coin;
+    const x = new Wallet();
+
+    $.shouldBeNumber(opts.m);
+    $.shouldBeNumber(opts.n);
+    $.checkArgument(Utils.checkValueInCollection(chain, Constants.CHAINS)); // checking in chains for simplicity
+    $.checkArgument(Utils.checkValueInCollection(opts.network, Constants.NETWORKS[chain]));
+
+    x.version = '1.0.0';
+    x.createdOn = Math.floor(Date.now() / 1000);
+    x.id = opts.id || Uuid.v4();
+    x.name = opts.name;
+    x.m = opts.m;
+    x.n = opts.n;
+    x.singleAddress = !!opts.singleAddress;
+    x.status = 'pending';
+    x.publicKeyRing = [];
+    x.addressIndex = 0;
+    x.copayers = [];
+    x.pubKey = opts.pubKey;
+    x.coin = opts.coin;
+    x.chain = opts.chain || Utils.getChain(x.coin);
+    x.network = opts.network;
+    x.derivationStrategy = opts.derivationStrategy || Constants.DERIVATION_STRATEGIES.BIP45;
+    x.addressType = opts.addressType || Constants.SCRIPT_TYPES.P2SH;
+
+    x.addressManager = AddressManager.create({
+      derivationStrategy: x.derivationStrategy
+    });
+    x.usePurpose48 = opts.usePurpose48;
+
+    x.scanStatus = null;
+
+    // v8 related
+    x.beRegistered = false; // Block explorer registered
+    x.beAuthPrivateKey2 = null;
+    x.beAuthPublicKey2 = null;
+
+    // x.nativeCashAddr opts is only for testing
+    x.nativeCashAddr = opts.nativeCashAddr == null ? (x.chain == 'bch' ? true : null) : opts.nativeCashAddr;
+
+    // hardware wallet related
+    x.hardwareSourcePublicKey = opts.hardwareSourcePublicKey;
+    // client derived
+    x.clientDerivedPublicKey = opts.clientDerivedPublicKey;
+
+    // Threshold signatures
+    x.tssVersion = opts.tssVersion;
+    x.tssKeyId = opts.tssKeyId;
+
+    return x;
+  }
+
+  static fromObj(obj: IWallet) {
+    const x = new Wallet();
+
+    $.shouldBeNumber(obj.m);
+    $.shouldBeNumber(obj.n);
+
+    x.version = obj.version;
+    x.createdOn = obj.createdOn;
+    x.id = obj.id;
+    x.name = obj.name;
+    x.m = obj.m;
+    x.n = obj.n;
+    x.singleAddress = !!obj.singleAddress;
+    x.status = obj.status;
+    x.publicKeyRing = obj.publicKeyRing;
+    x.copayers = (obj.copayers || []).map(copayer => Copayer.fromObj(copayer));
+    x.pubKey = obj.pubKey;
+    x.coin = obj.coin || Defaults.COIN;
+    x.chain = obj.chain || Utils.getChain(x.coin); // getChain -> backwards compatibility;
+    x.network = obj.network;
+    if (!x.network) {
+      x.network = obj.isTestnet ? Utils.getNetworkName(x.chain, 'testnet') : 'livenet';
+    }
+    x.derivationStrategy = obj.derivationStrategy || Constants.DERIVATION_STRATEGIES.BIP45;
+    x.addressType = obj.addressType || Constants.SCRIPT_TYPES.P2SH;
+    x.addressManager = AddressManager.fromObj(obj.addressManager);
+    x.scanStatus = obj.scanStatus;
+    x.beRegistered = obj.beRegistered;
+    x.beAuthPrivateKey2 = obj.beAuthPrivateKey2;
+    x.beAuthPublicKey2 = obj.beAuthPublicKey2;
+
+    x.nativeCashAddr = obj.nativeCashAddr;
+    x.usePurpose48 = obj.usePurpose48;
+
+    // hardware wallet related
+    x.hardwareSourcePublicKey = obj.hardwareSourcePublicKey;
+    // client derived
+    x.clientDerivedPublicKey = obj.clientDerivedPublicKey;
+
+    // Threshold signatures
+    x.tssVersion = obj.tssVersion;
+    x.tssKeyId = obj.tssKeyId;
+
+    return x;
+  }
+
+  toObject() {
+    const x: IWallet = JSON.parse(JSON.stringify(this));
+    x.isShared = this.isShared();
+    return x;
+  }
+
+  /**
+   * Get the maximum allowed number of required copayers.
+   * This is a limit imposed by the maximum allowed size of the scriptSig.
+   * @param {number} totalCopayers - the total number of copayers
+   * @return {number}
+   */
+  static getMaxRequiredCopayers(totalCopayers) {
+    return Wallet.COPAYER_PAIR_LIMITS[totalCopayers];
+  }
+
+  static verifyCopayerLimits(m, n) {
+    return n >= 1 && n <= 15 && m >= 1 && m <= n;
+  }
+
+  isShared() {
+    return this.n > 1;
+  }
+
+  isUTXOChain() {
+    return !!Constants.UTXO_CHAINS[this.chain.toUpperCase()];
+  }
+
+  updateBEKeys() {
+    $.checkState(this.isComplete(), 'Failed state: wallet incomplete at <updateBEKeys()>');
+
+    const chain = this.chain || Utils.getChain(this.coin); // getChain -> backwards compatibility
+    const bitcore = Bitcore[chain];
+    const salt = config.BE_KEY_SALT || Defaults.BE_KEY_SALT;
+
+    let seed = (this.copayers || []).map(c => c.xPubKey)
+      .sort()
+      .join('') +
+      Utils.getGenericName(this.network) + // Maintaining compatibility with previous versions
+      this.coin +
+      salt;
+    seed = bitcore.crypto.Hash.sha256(Buffer.from(seed));
+    const priv = bitcore.PrivateKey(seed, this.network);
+
+    this.beAuthPrivateKey2 = priv.toString();
+    // WARN!! => this will generate an uncompressed pub key.
+    this.beAuthPublicKey2 = priv.toPublicKey().toString();
+  }
+
+  _updatePublicKeyRing() {
+    this.publicKeyRing = (this.copayers || []).map(c => Utils.pick(c, ['xPubKey', 'requestPubKey']) as { xPubKey: string; requestPubKey: string });
+  }
+
+  addCopayer(copayer) {
+    $.checkState(copayer.coin == this.coin, 'Failed state: copayer.coin not equal to this.coin at <addCopayer()>');
+
+    this.copayers.push(copayer);
+    if (this.copayers.length < this.n) return;
+
+    this.status = 'complete';
+    this._updatePublicKeyRing();
+  }
+
+  addCopayerRequestKey(copayerId, requestPubKey, signature, restrictions, name) {
+    $.checkState(
+      this.copayers.length == this.n,
+      'Failed state: this.copayers.length == this.n at addCopayerRequestKey()'
+    );
+
+    const c: any = this.getCopayer(copayerId);
+
+    // new ones go first
+    c.requestPubKeys.unshift({
+      key: requestPubKey.toString(),
+      signature,
+      selfSigned: true,
+      restrictions: restrictions || {},
+      name: name || null
+    });
+  }
+
+  getCopayer(copayerId): Copayer {
+    return this.copayers.find(c => c.id == copayerId);
+  }
+
+  isComplete() {
+    return this.status == 'complete';
+  }
+
+  isScanning() {
+    return this.scanning;
+  }
+
+  isZceCompatible() {
+    return this.coin === 'bch' && this.addressType === 'P2PKH';
+  }
+
+  createAddress(isChange, step?, escrowInputs?) {
+    $.checkState(this.isComplete(), 'Failed state: this.isComplete() at <createAddress()>');
+
+    const path = this.addressManager.getNewAddressPath(isChange, step);
+    logger.debug('Deriving addr:' + path);
+    const scriptType = escrowInputs ? 'P2SH' : this.addressType;
+    return Address.derive(
+      this.id,
+      scriptType,
+      this.publicKeyRing,
+      path,
+      this.m,
+      this.coin,
+      this.network,
+      isChange,
+      this.chain,
+      !this.nativeCashAddr,
+      escrowInputs,
+      this.hardwareSourcePublicKey,
+      this.clientDerivedPublicKey
+    );
+  }
+
+  // Only for power scan
+  getSkippedAddress() {
+    $.checkState(this.isComplete(), 'Failed state: this.isComplete() at <getSkipeedAddress()>');
+
+    const next = this.addressManager.getNextSkippedPath();
+    if (!next) return;
+    const address = Address.derive(
+      this.id,
+      this.addressType,
+      this.publicKeyRing,
+      next.path,
+      this.m,
+      this.coin,
+      this.network,
+      next.isChange,
+      this.chain
+    );
+    return address;
+  }
+}

package/src/lib/notificationbroadcaster.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from 'events';
+
+let _instance;
+
+export class NotificationBroadcaster extends EventEmitter {
+  broadcast(eventName, notification, walletService) {
+    this.emit(eventName, notification, walletService);
+  }
+  static singleton() {
+    if (!_instance) {
+      _instance = new NotificationBroadcaster();
+    }
+    return _instance;
+  }
+}
+
+module.exports = NotificationBroadcaster.singleton();