@bitpay-labs/bitcore-wallet-service 11.5.2

package/src/externalservices/transak.ts

@@ -0,0 +1,320 @@
+import * as request from 'request';
+import config from '../config';
+import { ClientError } from '../lib/errors/clienterror';
+import { checkRequired } from '../lib/server';
+
+export class TransakService {
+  request: any = request;
+
+  private transakGetKeys(req, cleanBody: boolean = true) {
+    if (!config.transak) throw new Error('Transak missing credentials');
+
+    let env: 'sandbox' | 'production' | 'sandboxWeb' | 'productionWeb';
+    env = req.body.env === 'production' ? 'production' : 'sandbox';
+    if (req.body.context === 'web') {
+      env += 'Web';
+    }
+
+    if (cleanBody) {
+      delete req.body.env;
+      delete req.body.context;
+    }
+
+    const keys: {
+      API: string;
+      API_KEY: string;
+      SECRET_KEY: string;
+      WIDGET_API: string;
+    } = {
+      API: config.transak[env].api,
+      API_KEY: config.transak[env].apiKey,
+      SECRET_KEY: config.transak[env].secretKey,
+      WIDGET_API: config.transak[env].widgetApi
+    };
+
+    return keys;
+  }
+
+  transakGetAccessToken(req): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let keys;
+      try {
+        keys = this.transakGetKeys(req);
+      } catch (err) {
+        return reject(err);
+      }
+      const API = keys.API;
+      const API_KEY = keys.API_KEY;
+      const SECRET_KEY = keys.SECRET_KEY;
+
+      const headers = {
+        'Content-Type': 'application/json',
+        'api-secret': SECRET_KEY,
+      };
+
+      const body = {
+        apiKey: API_KEY
+      };
+
+      const URL: string = API + '/partners/api/v2/refresh-token';
+
+      this.request.post(
+        URL,
+        {
+          headers,
+          body,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve(data.body ? data.body : data);
+          }
+        }
+      );
+    });
+  }
+
+  transakGetCryptoCurrencies(req): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let keys;
+      try {
+        keys = this.transakGetKeys(req);
+      } catch (err) {
+        return reject(err);
+      }
+      const API = keys.API;
+
+      const headers = {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+      };
+
+      const URL: string = API + '/api/v2/currencies/crypto-currencies';
+
+      this.request.get(
+        URL,
+        {
+          headers,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve(data.body ? data.body : data);
+          }
+        }
+      );
+    });
+  }
+
+  transakGetFiatCurrencies(req): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let keys;
+      try {
+        keys = this.transakGetKeys(req);
+      } catch (err) {
+        return reject(err);
+      }
+      const API = keys.API;
+      const API_KEY = keys.API_KEY;
+
+      const headers = {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+      };
+
+      const URL: string = API + `/api/v2/currencies/fiat-currencies?apiKey=${API_KEY}`;
+
+      this.request.get(
+        URL,
+        {
+          headers,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve(data.body ? data.body : data);
+          }
+        }
+      );
+    });
+  }
+
+  transakGetQuote(req): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let keys;
+      try {
+        keys = this.transakGetKeys(req);
+      } catch (err) {
+        return reject(err);
+      }
+      const API = keys.API;
+      const API_KEY = keys.API_KEY;
+
+      if (!checkRequired(req.body, ['fiatCurrency', 'cryptoCurrency', 'network', 'paymentMethod'])) {
+        return reject(new ClientError("Transak's request missing arguments"));
+      }
+
+      const headers = {
+        Accept: 'application/json',
+      };
+
+      const qs: string[] = [];
+      qs.push('partnerApiKey=' + API_KEY);
+      qs.push('fiatCurrency=' + req.body.fiatCurrency);
+      qs.push('cryptoCurrency=' + req.body.cryptoCurrency);
+      qs.push('isBuyOrSell=BUY');
+      qs.push('network=' + req.body.network);
+      qs.push('paymentMethod=' + req.body.paymentMethod);
+
+      if (req.body.fiatAmount) qs.push('fiatAmount=' + req.body.fiatAmount);
+      if (req.body.cryptoAmount) qs.push('cryptoAmount=' + req.body.cryptoAmount);
+
+      const URL: string = API + `/api/v2/currencies/price?${qs.join('&')}`;
+
+      this.request.get(
+        URL,
+        {
+          headers,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve(data.body ? data.body : data);
+          }
+        }
+      );
+    });
+  }
+
+  transakGetSignedPaymentUrl(req): Promise<{ urlWithSignature: string }> {
+    return new Promise(async (resolve, reject) => {
+      const appRequiredParams = [
+        'walletAddress',
+        'redirectURL',
+        'fiatAmount',
+        'fiatCurrency',
+        'network',
+        'cryptoCurrencyCode',
+        'partnerOrderId',
+        'partnerCustomerId',
+      ];
+
+      const requiredParams = req.body.context === 'web' ? [] : appRequiredParams;
+      const referrerDomain = req.body.referrerDomain ?? req.body.context === 'web' ? 'bitpay.com' : 'bitpay';
+      let keys;
+      try {
+        keys = this.transakGetKeys(req, false);
+      } catch (err) {
+        return reject(err);
+      }
+      const API_KEY = keys.API_KEY;
+      const WIDGET_API = keys.WIDGET_API;
+
+      if (!checkRequired(req.body, requiredParams)) {
+        return reject(new ClientError("Transak's request missing arguments"));
+      }
+
+      let accessToken;
+      if (req.body.accessToken) {
+        accessToken = req.body.accessToken;
+      } else {
+        try {
+          const accessTokenData = await this.transakGetAccessToken(req);
+          accessToken = accessTokenData?.data?.accessToken;
+        } catch (err) {
+          return reject(err?.body ? err.body : err);
+        }
+      }
+
+      const headers = {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'access-token': accessToken,
+      };
+
+      const body = {
+        widgetParams: {
+          ...req.body,
+          apiKey: API_KEY,
+          referrerDomain,
+        },
+      };
+
+      const URL: string = WIDGET_API + '/api/v2/auth/session';
+
+      this.request.post(
+        URL,
+        {
+          headers,
+          body,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve({ urlWithSignature: data?.body?.data?.widgetUrl ?? data?.data?.widgetUrl });
+          }
+        }
+      );
+    });
+  }
+
+  transakGetOrderDetails(req): Promise<any> {
+    return new Promise(async (resolve, reject) => {
+      let keys;
+      try {
+        keys = this.transakGetKeys(req, false);
+      } catch (err) {
+        return reject(err);
+      }
+      const API = keys.API;
+
+      if (!checkRequired(req.body, ['orderId'])) {
+        return reject(new ClientError("Transak's request missing arguments"));
+      }
+
+      let accessToken;
+      if (req.body.accessToken) {
+        accessToken = req.body.accessToken;
+      } else {
+        try {
+          const accessTokenData = await this.transakGetAccessToken(req);
+          accessToken = accessTokenData?.data?.accessToken;
+        } catch (err) {
+          return reject(err?.body ? err.body : err);
+        }
+      }
+
+      const headers = {
+        Accept: 'application/json',
+        'access-token': accessToken,
+      };
+
+      const URL: string = API + `/partners/api/v2/order/${req.body.orderId}`;
+
+      this.request.get(
+        URL,
+        {
+          headers,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve(data.body ? data.body : data);
+          }
+        }
+      );
+    });
+  }
+}

package/src/externalservices/wyre.ts

@@ -0,0 +1,131 @@
+import { BitcoreLib as Bitcore } from '@bitpay-labs/crypto-wallet-core';
+import * as request from 'request';
+import config from '../config';
+import { ClientError } from '../lib/errors/clienterror';
+import { checkRequired } from '../lib/server';
+
+export class WyreService {
+  request: any = request;
+
+  private wyreGetKeys(req) {
+    if (!config.wyre) throw new Error('Wyre missing credentials');
+
+    let env = 'sandbox';
+    if (req.body.env && req.body.env == 'production') {
+      env = 'production';
+    }
+    delete req.body.env;
+
+    const keys = {
+      API: config.wyre[env].api,
+      API_KEY: config.wyre[env].apiKey,
+      SECRET_API_KEY: config.wyre[env].secretApiKey,
+      ACCOUNT_ID: config.wyre[env].appProviderAccountId
+    };
+
+    return keys;
+  }
+
+  wyreWalletOrderQuotation(req): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const keys = this.wyreGetKeys(req);
+      req.body.accountId = keys.ACCOUNT_ID;
+
+      if (req.body.amountIncludeFees) {
+        if (
+          !checkRequired(req.body, ['sourceAmount', 'sourceCurrency', 'destCurrency', 'dest', 'country', 'walletType'])
+        ) {
+          return reject(new ClientError("Wyre's request missing arguments"));
+        }
+      } else {
+        if (!checkRequired(req.body, ['amount', 'sourceCurrency', 'destCurrency', 'dest', 'country'])) {
+          return reject(new ClientError("Wyre's request missing arguments"));
+        }
+      }
+
+      const URL: string = `${keys.API}/v3/orders/quote/partner?timestamp=${Date.now().toString()}`;
+      const XApiSignature: string = URL + JSON.stringify(req.body);
+      const XApiSignatureHash: string = Bitcore.crypto.Hash.sha256hmac(
+        Buffer.from(XApiSignature),
+        Buffer.from(keys.SECRET_API_KEY)
+      ).toString('hex');
+
+      const headers = {
+        'Content-Type': 'application/json',
+        'X-Api-Key': keys.API_KEY,
+        'X-Api-Signature': XApiSignatureHash
+      };
+
+      this.request.post(
+        URL,
+        {
+          headers,
+          body: req.body,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve(data.body);
+          }
+        }
+      );
+    });
+  }
+
+  wyreWalletOrderReservation(req): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const keys = this.wyreGetKeys(req);
+      req.body.referrerAccountId = keys.ACCOUNT_ID;
+
+      if (req.body.amountIncludeFees) {
+        if (
+          !checkRequired(req.body, [
+            'sourceAmount',
+            'sourceCurrency',
+            'destCurrency',
+            'dest',
+            'country',
+            'paymentMethod'
+          ])
+        ) {
+          return reject(new ClientError("Wyre's request missing arguments"));
+        }
+      } else {
+        if (!checkRequired(req.body, ['amount', 'sourceCurrency', 'destCurrency', 'dest', 'paymentMethod'])) {
+          return reject(new ClientError("Wyre's request missing arguments"));
+        }
+      }
+
+      const URL: string = `${keys.API}/v3/orders/reserve?timestamp=${Date.now().toString()}`;
+      const XApiSignature: string = URL + JSON.stringify(req.body);
+      const XApiSignatureHash: string = Bitcore.crypto.Hash.sha256hmac(
+        Buffer.from(XApiSignature),
+        Buffer.from(keys.SECRET_API_KEY)
+      ).toString('hex');
+
+      const headers = {
+        'Content-Type': 'application/json',
+        'X-Api-Key': keys.API_KEY,
+        'X-Api-Signature': XApiSignatureHash
+      };
+
+      this.request.post(
+        URL,
+        {
+          headers,
+          body: req.body,
+          json: true
+        },
+        (err, data) => {
+          if (err) {
+            return reject(err.body ? err.body : err);
+          } else {
+            return resolve(data.body);
+          }
+        }
+      );
+    });
+  }
+}

package/src/fiatrateservice/fiatrateservice.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+import config from '../config';
+import { FiatRateService } from '../lib/fiatrateservice';
+import logger from '../lib/logger';
+
+const service = new FiatRateService();
+service.init(config, err => {
+  if (err) throw err;
+  service.startCron(config, err => {
+    if (err) throw err;
+
+    logger.info('Fiat rate service started');
+  });
+});

package/src/index.ts

@@ -0,0 +1,9 @@
+import { ExpressApp } from './lib/expressapp';
+import { Storage } from './lib/storage';
+
+export const BWS = {
+  ExpressApp,
+  Storage
+};
+
+export default BWS;

package/src/lib/bchaddresstranslator.ts

@@ -0,0 +1,59 @@
+import { BitcoreLib, BitcoreLibCash } from '@bitpay-labs/crypto-wallet-core';
+
+const Bitcore_ = {
+  btc: BitcoreLib,
+  bch: BitcoreLibCash
+};
+
+export class BCHAddressTranslator {
+  static getAddressCoin(address) {
+    try {
+      new Bitcore_['btc'].Address(address);
+      return 'legacy';
+    } catch {
+      try {
+        const a = new Bitcore_['bch'].Address(address);
+        if (a.toLegacyAddress() == address) return 'copay';
+        return 'cashaddr';
+      } catch {
+        return;
+      }
+    }
+  }
+
+  // Supports 3 formats:  legacy (1xxx, mxxxx); Copay: (Cxxx, Hxxx), Cashaddr(qxxx);
+  static translate(addresses, to, from?) {
+    let wasArray = true;
+    if (!Array.isArray(addresses)) {
+      wasArray = false;
+      addresses = [addresses];
+    }
+    from = from || BCHAddressTranslator.getAddressCoin(addresses[0]);
+
+    let ret;
+    if (from == to) {
+      ret = addresses;
+    } else {
+      ret = addresses.map(x => {
+        const bitcore = Bitcore_[from == 'legacy' ? 'btc' : 'bch'];
+        let orig;
+
+        try {
+          orig = new bitcore.Address(x).toObject();
+        } catch {
+          return null;
+        }
+
+        if (to == 'cashaddr') {
+          return Bitcore_['bch'].Address.fromObject(orig).toCashAddress(true);
+        } else if (to == 'copay') {
+          return Bitcore_['bch'].Address.fromObject(orig).toLegacyAddress();
+        } else if (to == 'legacy') {
+          return Bitcore_['btc'].Address.fromObject(orig).toString();
+        }
+      }).filter(x => !!x);
+    }
+    if (wasArray) return ret;
+    else return ret[0];
+  }
+}

package/src/lib/blockchainexplorer.ts

@@ -0,0 +1,84 @@
+import preconditions from 'preconditions';
+import { V8 } from './blockchainexplorers/v8';
+import { Common } from './common';
+
+const $ = preconditions.singleton();
+
+const { Utils } = Common;
+
+const PROVIDERS = {
+  v8: {
+    btc: {
+      livenet: 'https://api.bitcore.io',
+      testnet3: 'https://api.bitcore.io'
+    },
+    bch: {
+      livenet: 'https://api.bitcore.io',
+      testnet3: 'https://api.bitcore.io'
+    },
+    doge: {
+      livenet: 'https://api.bitcore.io',
+      testnet3: 'https://api.bitcore.io'
+    },
+    ltc: {
+      livenet: 'https://api.bitcore.io',
+      testnet4: 'https://api.bitcore.io'
+    },
+    xrp: {
+      livenet: 'https://api-xrp.bitcore.io',
+      testnet: 'https://api-xrp.bitcore.io'
+    },
+    eth: {
+      livenet: 'https://api-eth.bitcore.io',
+      sepolia: 'https://api-eth.bitcore.io'
+    },
+    matic: {
+      livenet: 'https://api-matic.bitcore.io',
+      amoy: 'https://api-matic.bitcore.io'
+    },
+    arb: {
+      livenet: 'https://api-eth.bitcore.io',
+      sepolia: 'https://api-eth.bitcore.io'
+    },
+    base: {
+      livenet: 'https://api-eth.bitcore.io',
+      sepolia: 'https://api-eth.bitcore.io'
+    },
+    op: {
+      livenet: 'https://api-eth.bitcore.io',
+      sepolia: 'https://api-eth.bitcore.io'
+    },
+    sol: {
+      livenet: 'https://api-sol.bitcore.io',
+      testnet: 'https://api-sol.bitcore.io',
+      devnet: 'https://api-sol.bitcore.io'
+    },
+  }
+};
+
+export function BlockChainExplorer(opts): V8 {
+  $.checkArgument(opts, 'Failed state: opts undefined at <BlockChainExplorer()>');
+
+  const provider = opts.provider || 'v8';
+  const chain = opts.chain?.toLowerCase() || Utils.getChain(opts.coin); // getChain -> backwards compatibility
+  const network = opts.network || 'livenet';
+  const url = opts.url || PROVIDERS[provider]?.[chain]?.[network];
+
+  $.checkState(url, `No url found for provider: ${provider}:${chain}:${network}`);
+
+  if (chain != 'bch' && opts.addressFormat) { throw new Error('addressFormat only supported for bch'); }
+  if (chain == 'bch' && !opts.addressFormat) { opts.addressFormat = 'cashaddr'; }
+
+  switch (provider) {
+    case 'v8':
+      return new V8({
+        chain,
+        network,
+        url,
+        apiPrefix: opts.apiPrefix,
+        userAgent: opts.userAgent
+      });
+    default:
+      throw new Error(`Provider not supported: ${provider}`);
+  }
+}