@cityofzion/blockchain-service 0.11.1 → 0.12.0

package/dist/CryptoCompareEDS.d.ts

@@ -0,0 +1,8 @@
+import { Currency, ExchangeDataService, GetTokenPriceHistory, NetworkType, Token, TokenPricesHistoryResponse, TokenPricesResponse } from './interfaces';
+export declare class CryptoCompareEDS implements ExchangeDataService {
+    #private;
+    networkType: NetworkType;
+    constructor(network: NetworkType, tokens?: Token[]);
+    getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]>;
+    getTokenPriceHistory(params: GetTokenPriceHistory): Promise<TokenPricesHistoryResponse[]>;
+}

package/dist/CryptoCompareEDS.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _CryptoCompareEDS_axiosInstance, _CryptoCompareEDS_tokens;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoCompareEDS = void 0;
+const axios_1 = __importDefault(require("axios"));
+class CryptoCompareEDS {
+    constructor(network, tokens = []) {
+        _CryptoCompareEDS_axiosInstance.set(this, void 0);
+        _CryptoCompareEDS_tokens.set(this, void 0);
+        this.networkType = network;
+        __classPrivateFieldSet(this, _CryptoCompareEDS_tokens, tokens, "f");
+        __classPrivateFieldSet(this, _CryptoCompareEDS_axiosInstance, axios_1.default.create({ baseURL: 'https://min-api.cryptocompare.com' }), "f");
+    }
+    getTokenPrices(currency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.networkType !== 'mainnet')
+                throw new Error('Exchange is only available on mainnet');
+            const tokenSymbols = __classPrivateFieldGet(this, _CryptoCompareEDS_tokens, "f").map(token => token.symbol);
+            const { data: prices } = yield __classPrivateFieldGet(this, _CryptoCompareEDS_axiosInstance, "f").get('/data/pricemultifull', {
+                params: {
+                    fsyms: tokenSymbols.join(','),
+                    tsyms: currency,
+                },
+            });
+            return Object.entries(prices.RAW)
+                .map(([symbol, priceObject]) => {
+                const price = priceObject[currency].PRICE;
+                const token = __classPrivateFieldGet(this, _CryptoCompareEDS_tokens, "f").find(token => token.symbol === symbol);
+                if (!token || !price)
+                    return;
+                return {
+                    symbol,
+                    price,
+                    hash: token === null || token === void 0 ? void 0 : token.hash,
+                };
+            })
+                .filter((price) => price !== undefined);
+        });
+    }
+    getTokenPriceHistory(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = `/data/${params.type === 'hour' ? 'histohour' : 'histoday'}`;
+            const response = yield __classPrivateFieldGet(this, _CryptoCompareEDS_axiosInstance, "f").get(path, {
+                params: {
+                    fsym: params.tokenSymbol,
+                    tsym: params.currency,
+                    limit: params.limit,
+                },
+            });
+            const history = [];
+            response.data.Data.forEach(data => {
+                const token = __classPrivateFieldGet(this, _CryptoCompareEDS_tokens, "f").find(token => token.symbol === params.tokenSymbol);
+                if (!token)
+                    return;
+                history.push({
+                    price: data.close,
+                    timestamp: data.time,
+                    symbol: params.tokenSymbol,
+                    hash: token.hash,
+                });
+            });
+            return history;
+        });
+    }
+}
+exports.CryptoCompareEDS = CryptoCompareEDS;
+_CryptoCompareEDS_axiosInstance = new WeakMap(), _CryptoCompareEDS_tokens = new WeakMap();

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './interfaces';
 export * from './BSAggregator';
 export * from './functions';
+export * from './CryptoCompareEDS';

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./BSAggregator"), exports);
 __exportStar(require("./functions"), exports);
+__exportStar(require("./CryptoCompareEDS"), exports);

package/dist/interfaces.d.ts

@@ -1,4 +1,5 @@
 import Transport from '@ledgerhq/hw-transport';
+import TypedEmitter from 'typed-emitter';
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type Account = {
     key: string;
@@ -32,15 +33,6 @@ export type TransferParam = {
     priorityFee?: string;
     isLedger?: boolean;
 };
-export type TokenPricesResponse = {
-    price: number;
-    symbol: string;
-    hash: string;
-};
-export type Currency = 'USD' | 'BRL' | 'EUR';
-export interface ExchangeDataService {
-    getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]>;
-}
 export interface BlockchainService<BSCustomName extends string = string> {
     readonly blockchainName: BSCustomName;
     readonly derivationPath: string;
@@ -156,6 +148,28 @@ export interface BlockchainDataService {
 export interface BDSClaimable {
     getUnclaimed(address: string): Promise<string>;
 }
+export type TokenPricesResponse = {
+    price: number;
+    symbol: string;
+    hash: string;
+};
+export type TokenPricesHistoryResponse = {
+    price: number;
+    timestamp: number;
+    symbol: string;
+    hash: string;
+};
+export type Currency = 'USD' | 'BRL' | 'EUR';
+export type GetTokenPriceHistory = {
+    tokenSymbol: string;
+    currency: Currency;
+    type: 'hour' | 'day';
+    limit: number;
+};
+export interface ExchangeDataService {
+    getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]>;
+    getTokenPriceHistory(params: GetTokenPriceHistory): Promise<TokenPricesHistoryResponse[]>;
+}
 export interface NftResponse {
     id: string;
     contractHash: string;
@@ -185,9 +199,14 @@ export type GetNftParam = {
     tokenId: string;
     contractHash: string;
 };
+export type HasTokenParam = {
+    address: string;
+    contractHash: string;
+};
 export interface NftDataService {
     getNftsByAddress(params: GetNftsByAddressParams): Promise<NftsResponse>;
     getNft(params: GetNftParam): Promise<NftResponse>;
+    hasToken(params: HasTokenParam): Promise<boolean>;
 }
 export type BuildNftUrlParams = {
     contractHash: string;
@@ -197,7 +216,12 @@ export interface ExplorerService {
     buildTransactionUrl(hash: string): string;
     buildNftUrl(params: BuildNftUrlParams): string;
 }
+export type LedgerServiceEmitter = TypedEmitter<{
+    getSignatureStart(): void | Promise<void>;
+    getSignatureEnd(): void | Promise<void>;
+}>;
 export interface LedgerService {
+    emitter: LedgerServiceEmitter;
     getLedgerTransport?: (account: Account) => Promise<Transport>;
     getAddress(transport: Transport): Promise<string>;
     getPublicKey(transport: Transport): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/blockchain-service",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -18,7 +18,9 @@
     "typescript": "4.9.5"
   },
   "dependencies": {
-    "@ledgerhq/hw-transport": "~6.30.5"
+    "@ledgerhq/hw-transport": "~6.30.5",
+    "axios": "1.5.1",
+    "typed-emitter": "~2.1.0"
   },
   "scripts": {
     "build": "tsc",