@cityofzion/blockchain-service 1.19.3 → 1.21.0

package/dist/functions.d.ts

@@ -1,4 +1,4 @@
-import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, IBSWithNeo3NeoXBridge, UntilIndexRecord } from './interfaces';
+import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithEncryption, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, IBSWithNeo3NeoXBridge, UntilIndexRecord } from './interfaces';
 export declare function hasNameService<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithNameService;
 export declare function isClaimable<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSClaimable<BSName>;
 export declare function isCalculableFee<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSCalculableFee<BSName>;
@@ -6,6 +6,7 @@ export declare function hasNft<BSName extends string = string>(service: Blockcha
 export declare function hasExplorerService<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithExplorerService;
 export declare function hasLedger<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithLedger<BSName>;
 export declare function hasNeo3NeoXBridge<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & IBSWithNeo3NeoXBridge<BSName>;
+export declare function hasEncryption<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithEncryption<BSName>;
 /**
  * @deprecated use `waitForAccountTransaction` instead
  */

package/dist/functions.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateAccountForBlockchainService = exports.generateAccount = exports.fetchAccounts = exports.waitForAccountTransaction = exports.waitForTransaction = exports.hasNeo3NeoXBridge = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+exports.generateAccountForBlockchainService = exports.generateAccount = exports.fetchAccounts = exports.waitForAccountTransaction = exports.waitForTransaction = exports.hasEncryption = exports.hasNeo3NeoXBridge = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
 const BSUtilsHelper_1 = require("./helpers/BSUtilsHelper");
 function hasNameService(service) {
     return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
@@ -39,6 +39,10 @@ function hasNeo3NeoXBridge(service) {
     return 'neo3NeoXBridgeService' in service;
 }
 exports.hasNeo3NeoXBridge = hasNeo3NeoXBridge;
+function hasEncryption(service) {
+    return 'encrypt' in service && 'decrypt' in service;
+}
+exports.hasEncryption = hasEncryption;
 /**
  * @deprecated use `waitForAccountTransaction` instead
  */

package/dist/helpers/BSBigNumberHelper.d.ts

@@ -4,6 +4,7 @@ type FormatNumberOptions = {
 };
 export declare class BSBigNumberHelper {
     static toDecimals(value: BigNumber, decimals?: number): string;
+    static toNumber(value: BigNumber): string;
     static fromNumber(value: string | number): BigNumber;
     static fromDecimals(value: string | number, decimals?: number): BigNumber;
     static format(value?: string | number | BigNumber, options?: FormatNumberOptions): string;

package/dist/helpers/BSBigNumberHelper.js

@@ -9,6 +9,9 @@ class BSBigNumberHelper {
     static toDecimals(value, decimals = 0) {
         return new bignumber_js_1.default(value).shiftedBy(decimals).toString();
     }
+    static toNumber(value) {
+        return value.toFixed();
+    }
     static fromNumber(value) {
         return new bignumber_js_1.default(value);
     }

package/dist/index.d.ts

@@ -2,11 +2,11 @@ export * from './constants/BSCommonConstants';
 export * from './helpers/BSFullTransactionsByAddressHelper';
 export * from './helpers/BSPromisesHelper';
 export * from './helpers/BSBigNumberHelper';
-export * from './helpers/BSTokenHelper';
 export * from './helpers/BSUtilsHelper';
 export * from './helpers/BSAccountHelper';
 export * from './services/exchange-data/CryptoCompareEDS';
 export * from './services/exchange-data/FlamingoForthewinEDS';
+export * from './services/token/TokenService';
 export * from './functions';
 export * from './interfaces';
 export * from './error';

package/dist/index.js

@@ -18,11 +18,11 @@ __exportStar(require("./constants/BSCommonConstants"), exports);
 __exportStar(require("./helpers/BSFullTransactionsByAddressHelper"), exports);
 __exportStar(require("./helpers/BSPromisesHelper"), exports);
 __exportStar(require("./helpers/BSBigNumberHelper"), exports);
-__exportStar(require("./helpers/BSTokenHelper"), exports);
 __exportStar(require("./helpers/BSUtilsHelper"), exports);
 __exportStar(require("./helpers/BSAccountHelper"), exports);
 __exportStar(require("./services/exchange-data/CryptoCompareEDS"), exports);
 __exportStar(require("./services/exchange-data/FlamingoForthewinEDS"), exports);
+__exportStar(require("./services/token/TokenService"), exports);
 __exportStar(require("./functions"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./error"), exports);

package/dist/interfaces.d.ts

@@ -40,6 +40,7 @@ export interface BlockchainService<BSName extends string = string, BSAvailableNe
     readonly feeToken: Token;
     exchangeDataService: ExchangeDataService;
     blockchainDataService: BlockchainDataService;
+    tokenService: ITokenService;
     tokens: Token[];
     nativeTokens: Token[];
     network: Network<BSAvailableNetworks>;
@@ -47,15 +48,17 @@ export interface BlockchainService<BSName extends string = string, BSAvailableNe
     setNetwork: (partialNetwork: Network<BSAvailableNetworks>) => void;
     generateAccountFromMnemonic(mnemonic: string, index: number): Account<BSName>;
     generateAccountFromKey(key: string): Account<BSName>;
-    decrypt(keyOrJson: string, password: string): Promise<Account<BSName>>;
-    encrypt(key: string, password: string): Promise<string>;
     validateAddress(address: string): boolean;
-    validateEncrypted(keyOrJson: string): boolean;
     validateKey(key: string): boolean;
     transfer(param: TransferParam<BSName>): Promise<string[]>;
 }
+export interface BSWithEncryption<BSName extends string = string> {
+    decrypt(keyOrJson: string, password: string): Promise<Account<BSName>>;
+    encrypt(key: string, password: string): Promise<string>;
+    validateEncrypted(keyOrJson: string): boolean;
+}
 export interface BSCalculableFee<BSName extends string = string> {
-    calculateTransferFee(param: TransferParam<BSName>, details?: boolean): Promise<string>;
+    calculateTransferFee(param: TransferParam<BSName>): Promise<string>;
 }
 export interface BSClaimable<BSName extends string = string> {
     readonly claimToken: Token;
@@ -98,11 +101,22 @@ export type TransactionTransferAsset = {
     token?: Token;
 };
 export type TransactionTransferNft = {
-    tokenId: string;
+    tokenHash: string;
     to: string;
     from: string;
     type: 'nft';
-    contractHash: string;
+    collectionHash: string;
+};
+type TransactionDefaultResponse = {
+    type: 'default';
+};
+export type TransactionBridgeNeo3NeoXResponse = {
+    type: 'bridgeNeo3NeoX';
+    data: {
+        amount: string;
+        token: TBridgeToken;
+        receiverAddress: string;
+    };
 };
 export type TransactionResponse = {
     hash: string;
@@ -111,7 +125,7 @@ export type TransactionResponse = {
     transfers: (TransactionTransferAsset | TransactionTransferNft)[];
     fee?: string;
     notifications: TransactionNotifications[];
-};
+} & (TransactionDefaultResponse | TransactionBridgeNeo3NeoXResponse);
 export type ContractParameter = {
     name: string;
     type: string;
@@ -140,14 +154,14 @@ export type FullTransactionNftEvent = {
     eventType: 'nft';
     amount?: string;
     methodName: string;
-    hash: string;
-    hashUrl?: string;
+    collectionHash: string;
+    collectionHashUrl?: string;
     to?: string;
     toUrl?: string;
     from?: string;
     fromUrl?: string;
     tokenType: 'generic' | (string & NonNullable<unknown>);
-    tokenId?: string;
+    tokenHash?: string;
     nftImageUrl?: string;
     nftUrl?: string;
     name?: string;
@@ -157,8 +171,8 @@ export type FullTransactionAssetEvent = {
     eventType: 'token';
     amount?: string;
     methodName: string;
-    hash: string;
-    hashUrl?: string;
+    contractHash: string;
+    contractHashUrl?: string;
     to?: string;
     toUrl?: string;
     from?: string;
@@ -166,6 +180,17 @@ export type FullTransactionAssetEvent = {
     token?: Token;
     tokenType: 'generic' | (string & NonNullable<unknown>);
 };
+type FullTransactionsItemDefault = {
+    type: 'default';
+};
+export type FullTransactionsItemBridgeNeo3NeoX = {
+    type: 'bridgeNeo3NeoX';
+    data: {
+        amount: string;
+        token: TBridgeToken;
+        receiverAddress: string;
+    };
+};
 export type FullTransactionsItem = {
     txId: string;
     txIdUrl?: string;
@@ -176,7 +201,7 @@ export type FullTransactionsItem = {
     networkFeeAmount?: string;
     systemFeeAmount?: string;
     events: (FullTransactionAssetEvent | FullTransactionNftEvent)[];
-};
+} & (FullTransactionsItemDefault | FullTransactionsItemBridgeNeo3NeoX);
 export type FullTransactionsByAddressResponse = {
     nextCursor?: string;
     data: FullTransactionsItem[];
@@ -237,14 +262,16 @@ export interface ExchangeDataService {
     getCurrencyRatio(currency: string): Promise<number>;
 }
 export interface NftResponse {
-    id: string;
-    contractHash: string;
-    collectionName?: string;
+    hash: string;
+    collection: {
+        name?: string;
+        image?: string;
+        hash: string;
+    };
     creator: {
         address: string;
         name?: string;
     };
-    collectionImage?: string;
     symbol: string;
     image?: string;
     name?: string;
@@ -262,12 +289,12 @@ export type GetNftsByAddressParams = {
     size?: number;
 };
 export type GetNftParam = {
-    tokenId: string;
-    contractHash: string;
+    tokenHash: string;
+    collectionHash: string;
 };
 export type HasTokenParam = {
     address: string;
-    contractHash: string;
+    collectionHash: string;
 };
 export interface NftDataService {
     getNftsByAddress(params: GetNftsByAddressParams): Promise<NftsResponse>;
@@ -275,8 +302,8 @@ export interface NftDataService {
     hasToken(params: HasTokenParam): Promise<boolean>;
 }
 export type BuildNftUrlParams = {
-    contractHash: string;
-    tokenId: string;
+    collectionHash: string;
+    tokenHash: string;
 };
 export interface ExplorerService {
     buildTransactionUrl(hash: string): string;
@@ -431,3 +458,21 @@ export interface INeo3NeoXBridgeService<BSName extends string = string> {
     getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams<BSName>): Promise<string>;
     getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams<BSName>): Promise<string>;
 }
+export type TTokenServicePredicateParams = {
+    hash: string;
+    symbol?: string;
+};
+export type TTokenServicePredicateByHashParams = string | {
+    hash: string;
+};
+export type TTokenServicePredicateBySymbolParams = string | {
+    symbol: string;
+};
+export interface ITokenService {
+    predicate({ hash, symbol }: TTokenServicePredicateParams): (params: TTokenServicePredicateParams) => boolean;
+    predicateByHash(tokenOrHash: TTokenServicePredicateByHashParams): (params: TTokenServicePredicateByHashParams) => boolean;
+    predicateBySymbol(tokenOrSymbol: TTokenServicePredicateBySymbolParams): (params: TTokenServicePredicateBySymbolParams) => boolean;
+    normalizeToken<T extends Token | Token[]>(token: T): T;
+    normalizeHash(hash: string): string;
+}
+export {};

package/dist/services/exchange-data/FlamingoForthewinEDS.d.ts

@@ -1,7 +1,7 @@
-import { ExchangeDataService, GetTokenPricesParams, TokenPricesResponse } from '../../interfaces';
+import { ExchangeDataService, GetTokenPricesParams, ITokenService, TokenPricesResponse } from '../../interfaces';
 import { CryptoCompareEDS } from './CryptoCompareEDS';
 export declare class FlamingoForthewinEDS extends CryptoCompareEDS implements ExchangeDataService {
     #private;
-    constructor();
+    constructor(tokenService: ITokenService);
     getTokenPrices({ tokens }: GetTokenPricesParams): Promise<TokenPricesResponse[]>;
 }

package/dist/services/exchange-data/FlamingoForthewinEDS.js

@@ -8,6 +8,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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");
@@ -16,30 +22,31 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _FlamingoForthewinEDS_flamingoAxiosInstance, _FlamingoForthewinEDS_forthewinAxiosInstance;
+var _FlamingoForthewinEDS_flamingoAxiosInstance, _FlamingoForthewinEDS_forthewinAxiosInstance, _FlamingoForthewinEDS_tokenService;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlamingoForthewinEDS = void 0;
 const axios_1 = __importDefault(require("axios"));
 const CryptoCompareEDS_1 = require("./CryptoCompareEDS");
-const BSTokenHelper_1 = require("../../helpers/BSTokenHelper");
 class FlamingoForthewinEDS extends CryptoCompareEDS_1.CryptoCompareEDS {
-    constructor() {
+    constructor(tokenService) {
         super();
         _FlamingoForthewinEDS_flamingoAxiosInstance.set(this, axios_1.default.create({ baseURL: 'https://neo-api.b-cdn.net/flamingo' }));
         _FlamingoForthewinEDS_forthewinAxiosInstance.set(this, axios_1.default.create({ baseURL: 'https://api.forthewin.network' }));
+        _FlamingoForthewinEDS_tokenService.set(this, void 0);
+        __classPrivateFieldSet(this, _FlamingoForthewinEDS_tokenService, tokenService, "f");
     }
     getTokenPrices({ tokens }) {
         return __awaiter(this, void 0, void 0, function* () {
             const { data: flamingoData } = yield __classPrivateFieldGet(this, _FlamingoForthewinEDS_flamingoAxiosInstance, "f").get('/live-data/prices/latest');
             const prices = [];
             const neoToken = tokens.find(({ symbol }) => symbol === 'NEO');
-            if (neoToken && !flamingoData.find(BSTokenHelper_1.BSTokenHelper.predicate(neoToken)))
+            if (neoToken && !flamingoData.find(__classPrivateFieldGet(this, _FlamingoForthewinEDS_tokenService, "f").predicate(neoToken)))
                 flamingoData.forEach(item => {
                     if (item.symbol === 'bNEO')
                         flamingoData.push(Object.assign(Object.assign({}, item), { symbol: neoToken.symbol, hash: neoToken.hash }));
                 });
             flamingoData.forEach(item => {
-                const token = tokens.find(BSTokenHelper_1.BSTokenHelper.predicate(item));
+                const token = tokens.find(__classPrivateFieldGet(this, _FlamingoForthewinEDS_tokenService, "f").predicate(item));
                 if (!token)
                     return;
                 prices.push({ usdPrice: item.usd_price, token });
@@ -47,10 +54,10 @@ class FlamingoForthewinEDS extends CryptoCompareEDS_1.CryptoCompareEDS {
             if (tokens.length > prices.length) {
                 const { data: forthewinData } = yield __classPrivateFieldGet(this, _FlamingoForthewinEDS_forthewinAxiosInstance, "f").get('/mainnet/prices');
                 Object.entries(forthewinData).forEach(([hash, usdPrice]) => {
-                    const hasPrice = !!prices.find(({ token }) => BSTokenHelper_1.BSTokenHelper.predicate({ hash })(token));
+                    const hasPrice = !!prices.find(({ token }) => __classPrivateFieldGet(this, _FlamingoForthewinEDS_tokenService, "f").predicate({ hash })(token));
                     if (hasPrice)
                         return;
-                    const foundToken = tokens.find(BSTokenHelper_1.BSTokenHelper.predicate({ hash }));
+                    const foundToken = tokens.find(__classPrivateFieldGet(this, _FlamingoForthewinEDS_tokenService, "f").predicate({ hash }));
                     if (!foundToken)
                         return;
                     prices.push({ usdPrice, token: foundToken });
@@ -61,4 +68,4 @@ class FlamingoForthewinEDS extends CryptoCompareEDS_1.CryptoCompareEDS {
     }
 }
 exports.FlamingoForthewinEDS = FlamingoForthewinEDS;
-_FlamingoForthewinEDS_flamingoAxiosInstance = new WeakMap(), _FlamingoForthewinEDS_forthewinAxiosInstance = new WeakMap();
+_FlamingoForthewinEDS_flamingoAxiosInstance = new WeakMap(), _FlamingoForthewinEDS_forthewinAxiosInstance = new WeakMap(), _FlamingoForthewinEDS_tokenService = new WeakMap();

package/dist/services/token/TokenService.d.ts

@@ -0,0 +1,12 @@
+import { ITokenService, Token, TTokenServicePredicateByHashParams, TTokenServicePredicateBySymbolParams, TTokenServicePredicateParams } from '../../interfaces';
+export type TBSTokenHelperPredicateParams = {
+    hash: string;
+    symbol?: string;
+};
+export declare abstract class TokenService implements ITokenService {
+    predicate({ hash, symbol }: TTokenServicePredicateParams): (params: TTokenServicePredicateParams) => boolean;
+    predicateByHash(tokenOrHash: TTokenServicePredicateByHashParams): (params: TTokenServicePredicateByHashParams) => boolean;
+    predicateBySymbol(tokenOrSymbol: TTokenServicePredicateBySymbolParams): (params: TTokenServicePredicateBySymbolParams) => boolean;
+    normalizeToken<T extends Token | Token[]>(token: T): T;
+    abstract normalizeHash(hash: string): string;
+}

package/dist/{helpers/BSTokenHelper.js → services/token/TokenService.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BSTokenHelper = void 0;
-class BSTokenHelper {
-    static predicate({ hash, symbol }) {
+exports.TokenService = void 0;
+class TokenService {
+    predicate({ hash, symbol }) {
         const normalizedHash = this.normalizeHash(hash);
         return (params) => {
             if (normalizedHash === this.normalizeHash(params.hash))
@@ -12,12 +12,12 @@ class BSTokenHelper {
             return false;
         };
     }
-    static predicateByHash(tokenOrHash) {
+    predicateByHash(tokenOrHash) {
         const hash = typeof tokenOrHash === 'string' ? tokenOrHash : tokenOrHash.hash;
         const normalizedHash = this.normalizeHash(hash);
         return (params) => normalizedHash === this.normalizeHash(typeof params === 'string' ? params : params.hash);
     }
-    static predicateBySymbol(tokenOrSymbol) {
+    predicateBySymbol(tokenOrSymbol) {
         const symbol = typeof tokenOrSymbol === 'string' ? tokenOrSymbol : tokenOrSymbol.symbol;
         const lowercaseSymbol = symbol.toLowerCase();
         return (params) => {
@@ -26,15 +26,11 @@ class BSTokenHelper {
             return lowercaseSymbol === lowercaseTokenSymbol;
         };
     }
-    static normalizeToken(token) {
+    normalizeToken(token) {
         if (Array.isArray(token)) {
             return token.map(item => (Object.assign(Object.assign({}, item), { hash: this.normalizeHash(item.hash) })));
         }
         return Object.assign(Object.assign({}, token), { hash: this.normalizeHash(token.hash) });
     }
-    static normalizeHash(hash) {
-        const fixed = hash.startsWith('0x') ? hash : `0x${hash}`;
-        return fixed.toLowerCase();
-    }
 }
-exports.BSTokenHelper = BSTokenHelper;
+exports.TokenService = TokenService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/blockchain-service",
-  "version": "1.19.3",
+  "version": "1.21.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",

package/dist/helpers/BSTokenHelper.d.ts

@@ -1,20 +0,0 @@
-import { Token } from '../interfaces';
-export type TBSTokenHelperPredicateParams = {
-    hash: string;
-    symbol?: string;
-};
-export declare class BSTokenHelper {
-    static predicate({ hash, symbol }: TBSTokenHelperPredicateParams): (params: TBSTokenHelperPredicateParams) => boolean;
-    static predicateByHash(tokenOrHash: string | {
-        hash: string;
-    }): (params: string | {
-        hash: string;
-    }) => boolean;
-    static predicateBySymbol(tokenOrSymbol: string | {
-        symbol: string;
-    }): (params: string | {
-        symbol: string;
-    }) => boolean;
-    static normalizeToken<T extends Token | Token[]>(token: T): T;
-    static normalizeHash(hash: string): string;
-}