@bitpay-labs/bitcore-wallet-service 11.5.2

package/src/lib/model/address.ts

@@ -0,0 +1,226 @@
+import {
+  BitcoreLib,
+  BitcoreLibCash,
+  BitcoreLibDoge,
+  BitcoreLibLtc,
+  Deriver
+} from '@bitpay-labs/crypto-wallet-core';
+import _ from 'lodash';
+import { singleton } from 'preconditions';
+import { Common } from '../common';
+import { AddressManager } from './addressmanager';
+
+const $ = singleton();
+const { Constants, Utils } = Common;
+
+export interface IAddress {
+  version: string;
+  createdOn: number;
+  address: string;
+  walletId: string;
+  isChange?: boolean;
+  isEscrow?: boolean;
+  path: string;
+  publicKeys: Array<string>;
+  coin: string;
+  chain: string;
+  network: string;
+  type: string;
+  hasActivity?: boolean;
+  beRegistered?: boolean;
+}
+
+export class Address {
+  version: string;
+  createdOn: number;
+  address: string;
+  walletId: string;
+  isChange: boolean;
+  isEscrow: boolean;
+  path: string;
+  publicKeys: string[];
+  coin: string;
+  chain: string;
+  network: string;
+  type: string;
+  hasActivity: boolean;
+  beRegistered: boolean;
+
+  static Bitcore = {
+    btc: BitcoreLib,
+    bch: BitcoreLibCash,
+    doge: BitcoreLibDoge,
+    ltc: BitcoreLibLtc
+  };
+
+  static create(opts) {
+    opts = opts || {};
+
+    const x = new Address();
+
+    opts.chain = opts.chain || Utils.getChain(opts.coin); // getChain -> backwards compatibility
+    $.checkArgument(Utils.checkValueInCollection(opts.chain, Constants.CHAINS));
+
+    x.version = '1.0.0';
+    x.createdOn = Math.floor(Date.now() / 1000);
+    x.address = opts.address;
+    x.walletId = opts.walletId;
+    x.isChange = opts.isChange;
+    x.isEscrow = opts.isEscrow;
+    x.path = opts.path;
+    x.publicKeys = opts.publicKeys;
+    x.coin = opts.chain;
+    x.chain = opts.chain;
+    x.network = Address.Bitcore[opts.chain]
+      ? Address.Bitcore[opts.chain].Address(x.address).toObject().network
+      : opts.network;
+    x.type = opts.type || Constants.SCRIPT_TYPES.P2SH;
+    x.hasActivity = undefined;
+    x.beRegistered = null;
+    return x;
+  }
+
+  static fromObj(obj) {
+    const x = new Address();
+
+    x.version = obj.version;
+    x.createdOn = obj.createdOn;
+    x.address = obj.address;
+    x.walletId = obj.walletId;
+    x.coin = obj.chain || Utils.getChain(obj.coin);
+    x.chain = x.coin;
+    x.network = Utils.getNetworkName(x.chain, obj.network) || obj.network;
+    x.isChange = obj.isChange;
+    x.isEscrow = obj.isEscrow;
+    x.path = obj.path;
+    x.publicKeys = obj.publicKeys;
+    x.type = obj.type || Constants.SCRIPT_TYPES.P2SH;
+    x.hasActivity = obj.hasActivity;
+    x.beRegistered = obj.beRegistered;
+    return x;
+  }
+
+  static _deriveAddress(scriptType, publicKeyRing, path, m, chain, network, noNativeCashAddr, escrowInputs?, hardwareSourcePublicKey?, clientDerivedPublicKey?) {
+    $.checkArgument(Utils.checkValueInCollection(scriptType, Constants.SCRIPT_TYPES));
+    const externSourcePublicKey = hardwareSourcePublicKey || clientDerivedPublicKey;
+    if (externSourcePublicKey) {
+      let bitcoreAddress;
+      try {
+        bitcoreAddress = Deriver.deriveAddressWithPath(chain.toUpperCase(), network, externSourcePublicKey, path, scriptType);
+      } catch {
+        // some chains (e.g. SOL) cannot derive address along path from pub key.
+        bitcoreAddress = Deriver.getAddress(chain.toUpperCase(), network, externSourcePublicKey, scriptType);
+      }
+      return {
+        address: bitcoreAddress.toString(),
+        path,
+        publicKeys: [externSourcePublicKey]
+      };
+    }
+
+    let publicKeys = (publicKeyRing || []).map(item => {
+      const xpub = Address.Bitcore[chain]
+        ? new Address.Bitcore[chain].HDPublicKey(item.xPubKey)
+        : new Address.Bitcore.btc.HDPublicKey(item.xPubKey);
+      return xpub.deriveChild(path).publicKey;
+    });
+
+    let bitcoreAddress;
+    switch (scriptType) {
+      case Constants.SCRIPT_TYPES.P2WSH:
+        const nestedWitness = false;
+        bitcoreAddress = Address.Bitcore[chain].Address.createMultisig(
+          publicKeys,
+          m,
+          network,
+          nestedWitness,
+          'witnessscripthash'
+        );
+        break;
+      case Constants.SCRIPT_TYPES.P2SH:
+        if (escrowInputs) {
+          const xpub = new Address.Bitcore[chain].HDPublicKey(publicKeyRing[0].xPubKey);
+          const inputPublicKeys = escrowInputs.map(input => xpub.deriveChild(input.path).publicKey);
+          bitcoreAddress = Address.Bitcore[chain].Address.createEscrow(inputPublicKeys, publicKeys[0], network);
+          publicKeys = [publicKeys[0], ...inputPublicKeys];
+        } else {
+          bitcoreAddress = Address.Bitcore[chain].Address.createMultisig(publicKeys, m, network);
+        }
+        break;
+      case Constants.SCRIPT_TYPES.P2WPKH:
+        bitcoreAddress = Address.Bitcore[chain].Address.fromPublicKey(publicKeys[0], network, 'witnesspubkeyhash');
+        break;
+      case Constants.SCRIPT_TYPES.P2PKH:
+        $.checkState(
+          Array.isArray(publicKeys) && publicKeys.length == 1,
+          'Failed state: publicKeys length < 1 or publicKeys not an array at <_deriveAddress()>'
+        );
+
+        if (Address.Bitcore[chain]) {
+          bitcoreAddress = Address.Bitcore[chain].Address.fromPublicKey(publicKeys[0], network);
+        } else {
+          const { addressIndex, isChange } = new AddressManager().parseDerivationPath(path);
+          const [{ xPubKey }] = publicKeyRing;
+          bitcoreAddress = Deriver.deriveAddress(chain.toUpperCase(), network, xPubKey, addressIndex, isChange);
+        }
+        break;
+      case Constants.SCRIPT_TYPES.P2TR:
+        // TODO: add support for multisig taproot
+        bitcoreAddress = Address.Bitcore[chain].Address.fromPublicKey(publicKeys[0], network, 'taproot');
+        break;
+    }
+
+    let addrStr = bitcoreAddress.toString(true);
+    if (noNativeCashAddr && chain == 'bch') {
+      addrStr = bitcoreAddress.toLegacyAddress();
+    }
+
+    return {
+      // bws still uses legacy addresses for BCH
+      address: addrStr,
+      path,
+      publicKeys: publicKeys.map(pk => pk.toString())
+    };
+  }
+
+  // noNativeCashAddr only for testing
+  static derive(
+    walletId,
+    scriptType,
+    publicKeyRing,
+    path,
+    m,
+    coin,
+    network,
+    isChange,
+    chain,
+    noNativeCashAddr = false,
+    escrowInputs?,
+    hardwareSourcePublicKey?,
+    clientDerivedPublicKey?
+  ) {
+    const raw = Address._deriveAddress(
+      scriptType,
+      publicKeyRing,
+      path,
+      m,
+      chain || Utils.getChain(coin), // getChain -> backwards compatibility
+      network,
+      noNativeCashAddr,
+      escrowInputs,
+      hardwareSourcePublicKey,
+      clientDerivedPublicKey
+    );
+    return Address.create(
+      _.extend(raw, {
+        coin,
+        chain,
+        network,
+        walletId,
+        type: scriptType,
+        isChange,
+        isEscrow: !!escrowInputs
+      })
+    );
+  }
+}

package/src/lib/model/addressmanager.ts

@@ -0,0 +1,138 @@
+import { singleton } from 'preconditions';
+import { Common } from '../common';
+
+const $ = singleton();
+const { Constants, Utils } = Common;
+export interface IAddressManager {
+  version: number;
+  derivationStrategy: string;
+  receiveAddressIndex: number;
+  changeAddressIndex: number;
+  copayerIndex: number;
+  skippedPaths: Array<{ path: string; isChange: boolean }>;
+}
+
+export class AddressManager {
+  version: number;
+  derivationStrategy: string;
+  receiveAddressIndex: number = 0;
+  changeAddressIndex: number = 0;
+  copayerIndex: number;
+  skippedPaths: Array<{ path: string; isChange: boolean }>;
+
+  static create(opts) {
+    opts = opts || {};
+
+    const x = new AddressManager();
+
+    x.version = 2;
+    x.derivationStrategy = opts.derivationStrategy || Constants.DERIVATION_STRATEGIES.BIP45;
+    $.checkState(
+      Utils.checkValueInCollection(x.derivationStrategy, Constants.DERIVATION_STRATEGIES),
+      'Failed state: x.derivation Stategy not in DERIVATION_STRATEGIES at <create()>'
+    );
+
+    x.receiveAddressIndex = 0;
+    x.changeAddressIndex = 0;
+    x.copayerIndex = Utils.isNumber(opts.copayerIndex) ? opts.copayerIndex : Constants.BIP45_SHARED_INDEX;
+    x.skippedPaths = [];
+
+    return x;
+  }
+
+  static fromObj(obj) {
+    const x = new AddressManager();
+
+    x.version = obj.version;
+    x.derivationStrategy = obj.derivationStrategy || Constants.DERIVATION_STRATEGIES.BIP45;
+    x.receiveAddressIndex = obj.receiveAddressIndex || 0;
+    x.changeAddressIndex = obj.changeAddressIndex || 0;
+    x.copayerIndex = obj.copayerIndex;
+
+    // this is not stored, only temporary.
+    x.skippedPaths = [];
+
+    return x;
+  }
+
+  static supportsCopayerBranches(derivationStrategy) {
+    return derivationStrategy == Constants.DERIVATION_STRATEGIES.BIP45;
+  }
+
+  _incrementIndex(isChange) {
+    if (isChange) {
+      this.changeAddressIndex++;
+    } else {
+      this.receiveAddressIndex++;
+    }
+  }
+
+  rewindIndex(isChange, step?, n?) {
+    step = step == null ? 1 : step;
+    n = n == null ? 1 : n;
+
+    if (isChange) {
+      this.changeAddressIndex = Math.max(0, this.changeAddressIndex - n * step);
+    } else {
+      this.receiveAddressIndex = Math.max(0, this.receiveAddressIndex - n * step);
+    }
+
+    // clear skipppedPath, since index is rewinded
+    // n address were actually derived.
+    this.skippedPaths = this.skippedPaths.splice(0, this.skippedPaths.length - step * n + n);
+  }
+
+  getCurrentIndex(isChange) {
+    return isChange ? this.changeAddressIndex : this.receiveAddressIndex;
+  }
+
+  getBaseAddressPath(isChange) {
+    return (
+      'm/' +
+      (this.derivationStrategy == Constants.DERIVATION_STRATEGIES.BIP45 ? this.copayerIndex + '/' : '') +
+      (isChange ? 1 : 0) +
+      '/' +
+      0
+    );
+  }
+
+  getCurrentAddressPath(isChange) {
+    return (
+      'm/' +
+      (this.derivationStrategy == Constants.DERIVATION_STRATEGIES.BIP45 ? this.copayerIndex + '/' : '') +
+      (isChange ? 1 : 0) +
+      '/' +
+      (isChange ? this.changeAddressIndex : this.receiveAddressIndex)
+    );
+  }
+
+  getNewAddressPath(isChange, step = 1) {
+    let ret;
+    let i = 0;
+    step = step || 1;
+
+    while (i++ < step) {
+      if (ret) {
+        this.skippedPaths.push({ path: ret, isChange });
+      }
+
+      ret = this.getCurrentAddressPath(isChange);
+      this._incrementIndex(isChange);
+    }
+    return ret;
+  }
+
+  getNextSkippedPath() {
+    if (!this.skippedPaths?.length) return null;
+
+    const ret = this.skippedPaths.pop();
+    return ret;
+  }
+
+  parseDerivationPath(path) {
+    const pathIndex = /m\/([0-9]*)\/([0-9]*)/;
+    const [_input, changeIndex, addressIndex] = path.match(pathIndex);
+    const isChange = changeIndex > 0;
+    return { _input, addressIndex, isChange };
+  }
+}

package/src/lib/model/advertisement.ts

@@ -0,0 +1,84 @@
+import _ from 'lodash';
+
+export interface IAdvertisement {
+  name: string;
+  advertisementId: string;
+  type: string;
+  title: string;
+  country: string;
+  body: string;
+  imgUrl: string;
+  linkText: string;
+  linkUrl: string;
+  app: string;
+  dismissible: boolean;
+  signature: boolean;
+  isAdActive: boolean;
+  isTesting: boolean;
+  appVersion: string;
+}
+
+export class Advertisement {
+  advertisementId: string;
+  name: string;
+  title: string;
+  country: string;
+  type: string;
+  body: string;
+  imgUrl: string;
+  linkText: string;
+  linkUrl: string;
+  app: string;
+  dismissible: boolean;
+  signature: boolean;
+  isAdActive: boolean;
+  isTesting: boolean;
+  appVersion: string;
+
+  static create(opts) {
+    opts = opts || {};
+    const x = new Advertisement();
+    x.name = opts.name;
+    x.title = opts.title;
+    x.country = opts.country;
+    x.type = opts.type;
+    x.body = opts.body;
+    x.imgUrl = opts.imgUrl;
+    x.linkText = opts.linkText;
+    x.linkUrl = opts.linkUrl;
+    x.app = opts.app;
+    x.dismissible = opts.dismissible;
+    x.signature = opts.signature;
+    x.isAdActive = opts.isAdActive;
+    x.isTesting = opts.isTesting;
+    x.appVersion = opts.appVersion;
+
+    return x;
+  }
+
+  static fromObj(obj) {
+    const x = new Advertisement();
+    x.name = obj.name;
+    x.advertisementId = obj.advertisementId;
+    x.title = obj.title;
+    x.country = obj.country;
+    x.type = obj.type;
+    x.body = obj.body;
+    x.imgUrl = obj.imgUrl;
+    x.linkText = obj.linkText;
+    x.linkUrl = obj.linkUrl;
+    x.app = obj.app;
+    x.dismissible = obj.dismissible;
+    x.signature = obj.signature;
+    x.isAdActive = obj.isAdActive;
+    x.isTesting = obj.isTesting;
+    x.appVersion = obj.appVersion;
+
+    return x;
+  }
+
+  toObject() {
+    const x: any = _.cloneDeep(this);
+    return x;
+  }
+}

package/src/lib/model/copayer.ts

@@ -0,0 +1,162 @@
+import { singleton } from 'preconditions';
+import sjcl from 'sjcl';
+import { Common } from '../common';
+import { Address } from './address';
+import { AddressManager, IAddressManager } from './addressmanager';
+
+const $ = singleton();
+const {
+  Constants,
+  Defaults,
+  Utils
+} = Common;
+
+export interface ICopayer {
+  version: number;
+  createdOn: number;
+  coin: string;
+  xPubKey: string;
+  id: string;
+  name: string;
+  requestPubKey: string;
+  signature: string;
+  requestPubKeys: Array<{
+    key: string;
+    signature: string;
+  }>;
+  customData?: any;
+  walletId: string;
+  isSupportStaff?: boolean;
+  isMarketingStaff?: boolean;
+  addressManager?: IAddressManager;
+}
+
+export class Copayer {
+  version: number;
+  createdOn: number;
+  coin: string;
+  chain: string;
+  xPubKey: string;
+  hardwareSourcePublicKey: string;
+  clientDerivedPublicKey: string;
+  id: string;
+  name: string;
+  requestPubKey: string;
+  signature: string;
+  requestPubKeys: Array<{
+    key: string;
+    signature: string;
+  }>;
+  customData?: any;
+  addressManager: AddressManager;
+  walletId: string;
+  isSupportStaff?: boolean;
+  isMarketingStaff?: boolean;
+
+  static xPubToCopayerId(coin, xpub) {
+    const str = coin == Defaults.COIN ? xpub : coin + xpub;
+    const hash = sjcl.hash.sha256.hash(str);
+    return sjcl.codec.hex.fromBits(hash);
+  }
+
+  static create(opts) {
+    opts = opts || {};
+    if (!opts.hardwareSourcePublicKey && !opts.clientDerivedPublicKey) {
+      $.checkArgument(opts.xPubKey, 'Missing copayer extended public key');
+    }
+    $.checkArgument(opts.requestPubKey, 'Missing copayer request public key')
+      .checkArgument(opts.signature, 'Missing copayer request public key signature');
+
+    $.checkArgument(Utils.checkValueInCollection(opts.coin, Constants.CHAINS));
+
+    opts.copayerIndex = opts.copayerIndex || 0;
+
+    const x = new Copayer();
+
+    x.version = 2;
+    x.createdOn = Math.floor(Date.now() / 1000);
+    x.coin = opts.coin;
+    x.chain = opts.chain || opts.coin;
+    x.xPubKey = opts.xPubKey;
+    x.hardwareSourcePublicKey = opts.hardwareSourcePublicKey;
+    x.clientDerivedPublicKey = opts.clientDerivedPublicKey;
+    x.id = Copayer.xPubToCopayerId(opts.chain, x.xPubKey);
+    x.name = opts.name;
+    x.requestPubKey = opts.requestPubKey;
+    x.signature = opts.signature;
+    x.requestPubKeys = [
+      {
+        key: opts.requestPubKey,
+        signature: opts.signature
+      }
+    ];
+
+    const derivationStrategy = opts.derivationStrategy || Constants.DERIVATION_STRATEGIES.BIP45;
+    if (AddressManager.supportsCopayerBranches(derivationStrategy)) {
+      x.addressManager = AddressManager.fromObj({
+        derivationStrategy,
+        copayerIndex: opts.copayerIndex
+      });
+    }
+
+    x.customData = opts.customData;
+
+    return x;
+  }
+
+  static fromObj(obj) {
+    const x = new Copayer();
+
+    x.version = obj.version;
+    x.createdOn = obj.createdOn;
+    x.coin = obj.coin || Defaults.COIN;
+    x.chain = obj.chain || x.coin;
+    x.id = obj.id || obj.copayerId;
+    x.name = obj.name;
+    x.xPubKey = obj.xPubKey;
+    x.hardwareSourcePublicKey = obj.hardwareSourcePublicKey;
+    x.clientDerivedPublicKey = obj.clientDerivedPublicKey;
+    x.requestPubKey = obj.requestPubKey;
+    x.signature = obj.signature;
+
+    if (parseInt(x.version?.toString()) == 1) {
+      x.requestPubKeys = [
+        {
+          key: x.requestPubKey,
+          signature: x.signature
+        }
+      ];
+      x.version = 2;
+    } else {
+      x.requestPubKeys = obj.requestPubKeys;
+    }
+
+    if (obj.addressManager) {
+      x.addressManager = AddressManager.fromObj(obj.addressManager);
+    }
+    x.customData = obj.customData;
+    x.walletId = obj.walletId;
+    x.isSupportStaff = obj.isSupportStaff;
+    x.isMarketingStaff = obj.isMarketingStaff;
+
+    return x;
+  }
+
+  createAddress(wallet, isChange) {
+    $.checkState(wallet.isComplete(), 'Failed state: wallet incomplete at <createAddress()>');
+
+    const path = this.addressManager.getNewAddressPath(isChange);
+    const address = Address.derive(
+      wallet.id,
+      wallet.addressType,
+      wallet.publicKeyRing,
+      path,
+      wallet.m,
+      wallet.coin,
+      wallet.network,
+      isChange,
+      wallet.chain
+    );
+    return address;
+  }
+}

package/src/lib/model/email.ts

@@ -0,0 +1,103 @@
+import _ from 'lodash';
+import Uuid from 'uuid';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+interface IEmail {
+  version: number;
+  createdOn: number;
+  id: number;
+  walletId: string;
+  copayerId: string;
+  from: string;
+  to: string;
+  subject: string;
+  bodyPlain: string;
+  bodyHtml: string;
+  status: string;
+  attempts: number;
+  lastAttemptOn?: number;
+  notificationId: string;
+  language: string;
+}
+
+export class Email {
+  version: number;
+  createdOn: number;
+  id: string | number;
+  walletId: string;
+  copayerId: string;
+  from: string;
+  to: string;
+  subject: string;
+  bodyPlain: string;
+  bodyHtml: string;
+  status: string;
+  attempts: number;
+  lastAttemptOn?: number;
+  notificationId: string;
+  language: string;
+
+  static create(opts) {
+    opts = opts || {};
+
+    const x = new Email();
+
+    x.version = 2;
+    const now = Date.now();
+    x.createdOn = Math.floor(now / 1000);
+    x.id = _.padStart(now.toString(), 14, '0') + Uuid.v4();
+    x.walletId = opts.walletId;
+    x.copayerId = opts.copayerId;
+    x.from = opts.from;
+    x.to = opts.to;
+    x.subject = opts.subject;
+    x.bodyPlain = opts.bodyPlain;
+    x.bodyHtml = opts.bodyHtml;
+    x.status = 'pending';
+    x.attempts = 0;
+    x.lastAttemptOn = null;
+    x.notificationId = opts.notificationId;
+    x.language = opts.language || 'en';
+    return x;
+  }
+
+  static fromObj(obj) {
+    const x = new Email();
+
+    x.version = obj.version;
+    x.createdOn = obj.createdOn;
+    x.id = obj.id;
+    x.walletId = obj.walletId;
+    x.copayerId = obj.copayerId;
+    x.from = obj.from;
+    x.to = obj.to;
+    x.subject = obj.subject;
+    if (parseInt(x.version.toString()) == 1) {
+      x.bodyPlain = obj.body;
+      x.version = 2;
+    } else {
+      x.bodyPlain = obj.bodyPlain;
+    }
+    x.bodyHtml = obj.bodyHtml;
+    x.status = obj.status;
+    x.attempts = obj.attempts;
+    x.lastAttemptOn = obj.lastAttemptOn;
+    x.notificationId = obj.notificationId;
+    x.language = obj.language;
+    return x;
+  }
+
+  _logAttempt(result) {
+    this.attempts++;
+    this.lastAttemptOn = Math.floor(Date.now() / 1000);
+    this.status = result;
+  }
+
+  setSent() {
+    this._logAttempt('sent');
+  }
+
+  setFail() {
+    this._logAttempt('fail');
+  }
+}