@cityofzion/blockchain-service 1.21.1 → 1.21.3

package/dist/functions.d.ts

@@ -1,22 +1,22 @@
-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>;
-export declare function hasNft<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithNft;
-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>;
+import { TBSAccount, IBlockchainService, IBSWithClaim, IBSWithEncryption, IBSWithExplorer, IBSWithFee, IBSWithLedger, IBSWithNameService, IBSWithNeo3NeoXBridge, IBSWithNft, TUntilIndexRecord } from './interfaces';
+export declare function hasNameService<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithNameService;
+export declare function isClaimable<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithClaim<BSName>;
+export declare function isCalculableFee<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithFee<BSName>;
+export declare function hasNft<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithNft;
+export declare function hasExplorerService<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithExplorer;
+export declare function hasLedger<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithLedger<BSName>;
+export declare function hasNeo3NeoXBridge<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithNeo3NeoXBridge<BSName>;
+export declare function hasEncryption<BSName extends string = string>(service: IBlockchainService<BSName>): service is IBlockchainService<BSName> & IBSWithEncryption<BSName>;
 /**
  * @deprecated use `waitForAccountTransaction` instead
  */
-export declare function waitForTransaction<BSName extends string = string>(service: BlockchainService<BSName>, txId: string): Promise<boolean>;
+export declare function waitForTransaction<BSName extends string = string>(service: IBlockchainService<BSName>, txId: string): Promise<boolean>;
 export declare function waitForAccountTransaction<BSName extends string = string>(params: {
-    service: BlockchainService<BSName>;
+    service: IBlockchainService<BSName>;
     txId: string;
     address: string;
     maxAttempts?: number;
 }): Promise<boolean>;
-export declare function fetchAccounts<BSName extends string = string>(blockchainServices: BlockchainService<BSName>, initialIndex: number, getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Account<BSName>[]>;
-export declare function generateAccount<BSName extends string = string>(blockchainServices: BlockchainService<BSName>, initialIndex: number, untilIndex: number, getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Account<BSName>[]>;
-export declare function generateAccountForBlockchainService<BSName extends string = string>(blockchainServices: BlockchainService<BSName>[], getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Map<BSName, Account<BSName>[]>>;
+export declare function fetchAccounts<BSName extends string = string>(service: IBlockchainService<BSName>, initialIndex: number, getAccountCallback: (service: IBlockchainService<BSName>, index: number) => Promise<TBSAccount<BSName>>): Promise<TBSAccount<BSName>[]>;
+export declare function generateAccount<BSName extends string = string>(service: IBlockchainService<BSName>, initialIndex: number, untilIndex: number, getAccountCallback: (service: IBlockchainService<BSName>, index: number) => Promise<TBSAccount<BSName>>): Promise<TBSAccount<BSName>[]>;
+export declare function generateAccountForBlockchainService<BSName extends string = string>(services: IBlockchainService<BSName>[], getAccountCallback: (service: IBlockchainService<BSName>, index: number) => Promise<TBSAccount<BSName>>, untilIndexByBlockchainService?: TUntilIndexRecord<BSName>): Promise<Map<BSName, TBSAccount<BSName>[]>>;

package/dist/functions.js

@@ -9,40 +9,44 @@ 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.hasEncryption = exports.hasNeo3NeoXBridge = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+exports.hasNameService = hasNameService;
+exports.isClaimable = isClaimable;
+exports.isCalculableFee = isCalculableFee;
+exports.hasNft = hasNft;
+exports.hasExplorerService = hasExplorerService;
+exports.hasLedger = hasLedger;
+exports.hasNeo3NeoXBridge = hasNeo3NeoXBridge;
+exports.hasEncryption = hasEncryption;
+exports.waitForTransaction = waitForTransaction;
+exports.waitForAccountTransaction = waitForAccountTransaction;
+exports.fetchAccounts = fetchAccounts;
+exports.generateAccount = generateAccount;
+exports.generateAccountForBlockchainService = generateAccountForBlockchainService;
 const BSUtilsHelper_1 = require("./helpers/BSUtilsHelper");
 function hasNameService(service) {
     return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
 }
-exports.hasNameService = hasNameService;
 function isClaimable(service) {
     return 'claim' in service && 'claimToken' in service && 'getUnclaimed' in service.blockchainDataService;
 }
-exports.isClaimable = isClaimable;
 function isCalculableFee(service) {
     return 'calculateTransferFee' in service;
 }
-exports.isCalculableFee = isCalculableFee;
 function hasNft(service) {
     return 'nftDataService' in service;
 }
-exports.hasNft = hasNft;
 function hasExplorerService(service) {
     return 'explorerService' in service;
 }
-exports.hasExplorerService = hasExplorerService;
 function hasLedger(service) {
     return 'ledgerService' in service;
 }
-exports.hasLedger = hasLedger;
 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
  */
@@ -65,7 +69,6 @@ function waitForTransaction(service, txId) {
         return false;
     });
 }
-exports.waitForTransaction = waitForTransaction;
 function waitForAccountTransaction(params) {
     return __awaiter(this, void 0, void 0, function* () {
         const { address, maxAttempts = 10, service, txId } = params;
@@ -86,16 +89,15 @@ function waitForAccountTransaction(params) {
         return false;
     });
 }
-exports.waitForAccountTransaction = waitForAccountTransaction;
-function fetchAccounts(blockchainServices, initialIndex, getAccountCallback) {
+function fetchAccounts(service, initialIndex, getAccountCallback) {
     return __awaiter(this, void 0, void 0, function* () {
         const accounts = [];
         let index = initialIndex;
         let shouldBreak = false;
         while (!shouldBreak) {
-            const generatedAccount = yield getAccountCallback(blockchainServices, index);
+            const generatedAccount = yield getAccountCallback(service, index);
             try {
-                const { transactions } = yield blockchainServices.blockchainDataService.getTransactionsByAddress({
+                const { transactions } = yield service.blockchainDataService.getTransactionsByAddress({
                     address: generatedAccount.address,
                 });
                 if (!transactions || transactions.length <= 0)
@@ -110,24 +112,22 @@ function fetchAccounts(blockchainServices, initialIndex, getAccountCallback) {
         return accounts;
     });
 }
-exports.fetchAccounts = fetchAccounts;
-function generateAccount(blockchainServices, initialIndex, untilIndex, getAccountCallback) {
+function generateAccount(service, initialIndex, untilIndex, getAccountCallback) {
     return __awaiter(this, void 0, void 0, function* () {
         const accounts = [];
         let index = initialIndex;
         while (index <= untilIndex) {
-            const generatedAccount = yield getAccountCallback(blockchainServices, index);
+            const generatedAccount = yield getAccountCallback(service, index);
             accounts.push(generatedAccount);
             index++;
         }
         return accounts;
     });
 }
-exports.generateAccount = generateAccount;
-function generateAccountForBlockchainService(blockchainServices, getAccountCallback, untilIndexByBlockchainService) {
+function generateAccountForBlockchainService(services, getAccountCallback, untilIndexByBlockchainService) {
     return __awaiter(this, void 0, void 0, function* () {
         const accountsByBlockchainService = new Map();
-        const promises = blockchainServices.map((service) => __awaiter(this, void 0, void 0, function* () {
+        const promises = services.map((service) => __awaiter(this, void 0, void 0, function* () {
             var _a;
             const firstAccount = yield getAccountCallback(service, 0);
             const untilIndex = (_a = untilIndexByBlockchainService === null || untilIndexByBlockchainService === void 0 ? void 0 : untilIndexByBlockchainService[service.name]) === null || _a === void 0 ? void 0 : _a[firstAccount.address];
@@ -144,4 +144,3 @@ function generateAccountForBlockchainService(blockchainServices, getAccountCallb
         return accountsByBlockchainService;
     });
 }
-exports.generateAccountForBlockchainService = generateAccountForBlockchainService;

package/dist/helpers/BSBigNumberHelper.d.ts

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

package/dist/helpers/BSBigNumberHelper.js

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BSBigNumberHelper = void 0;
+exports.BSBigNumber = exports.BSBigNumberHelper = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 class BSBigNumberHelper {
     static toDecimals(value, decimals = 0) {
         return new bignumber_js_1.default(value).shiftedBy(decimals).toString();
     }
-    static toNumber(value) {
-        return value.toFixed();
+    static toNumber(value, decimals) {
+        return typeof decimals === 'number' ? value.toFixed(decimals) : value.toFixed();
     }
     static fromNumber(value) {
         return new bignumber_js_1.default(value);
@@ -35,10 +35,11 @@ class BSBigNumberHelper {
             const formattedValue = bigValue.decimalPlaces(decimals, bignumber_js_1.default.ROUND_DOWN);
             return formattedValue.toFixed();
         }
-        catch (error) {
+        catch (_b) {
             console.error('Invalid value provided to format:', value);
             return '0';
         }
     }
 }
 exports.BSBigNumberHelper = BSBigNumberHelper;
+exports.BSBigNumber = bignumber_js_1.default;

package/dist/helpers/BSFullTransactionsByAddressHelper.d.ts

@@ -1,4 +1,10 @@
-import { FullTransactionsByAddressParams } from '../interfaces';
+import { TFullTransactionsByAddressParams, IBlockchainService, TBSNetworkId } from '../interfaces';
+type TValidateFullTransactionsByAddressParams<N extends string, A extends TBSNetworkId> = TFullTransactionsByAddressParams & {
+    service: IBlockchainService<N, A>;
+    supportedNetworksIds?: string[];
+    maxPageSize?: number;
+};
 export declare class BSFullTransactionsByAddressHelper {
-    static validateFullTransactionsByAddressParams(params: Omit<FullTransactionsByAddressParams, 'nextCursor'>): void;
+    static validateFullTransactionsByAddressParams<N extends string, A extends TBSNetworkId>(params: TValidateFullTransactionsByAddressParams<N, A>): void;
 }
+export {};

package/dist/helpers/BSFullTransactionsByAddressHelper.js

@@ -4,6 +4,7 @@ exports.BSFullTransactionsByAddressHelper = void 0;
 const date_fns_1 = require("date-fns");
 class BSFullTransactionsByAddressHelper {
     static validateFullTransactionsByAddressParams(params) {
+        var _a;
         if (!params.dateFrom)
             throw new Error('Missing dateFrom param');
         if (!params.dateTo)
@@ -20,6 +21,14 @@ class BSFullTransactionsByAddressHelper {
             throw new Error('Invalid date order because dateFrom is greater than dateTo');
         if ((0, date_fns_1.differenceInYears)(dateTo, dateFrom) >= 1)
             throw new Error('Date range greater than one year');
+        const maxPageSize = (_a = params.maxPageSize) !== null && _a !== void 0 ? _a : 500;
+        if (typeof params.pageSize === 'number' &&
+            (isNaN(params.pageSize) || params.pageSize < 1 || params.pageSize > maxPageSize))
+            throw new Error(`Page size should be between 1 and ${maxPageSize}`);
+        if (params.supportedNetworksIds && !params.supportedNetworksIds.includes(params.service.network.id))
+            throw new Error('Network not supported');
+        if (!params.service.validateAddress(params.address))
+            throw new Error('Invalid address param');
     }
 }
 exports.BSFullTransactionsByAddressHelper = BSFullTransactionsByAddressHelper;

package/dist/helpers/BSKeychainHelper.d.ts

@@ -0,0 +1,8 @@
+export declare class BSKeychainHelper {
+    static generateNeoPrivateKeyFromMnemonic(mnemonic: string, path: string): string;
+    static generateMnemonic(): string;
+    static isValidMnemonic(word: string | string[]): boolean;
+    static isMnemonic(word: string | string[]): boolean;
+    static extractIndexFromPath(bip44Path: string): number;
+    static getBip44Path(path: string, order?: number): string;
+}

package/dist/helpers/BSKeychainHelper.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSKeychainHelper = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const crypto_1 = __importDefault(require("crypto"));
+const bip39 = __importStar(require("bip39"));
+const elliptic_1 = __importDefault(require("elliptic"));
+class BSKeychainHelper {
+    static generateNeoPrivateKeyFromMnemonic(mnemonic, path) {
+        const seed = bip39.mnemonicToSeedSync(mnemonic);
+        const masterKeyHmac = crypto_1.default
+            .createHmac('sha512', Buffer.from('Nist256p1 seed'))
+            .update(Uint8Array.from(seed))
+            .digest();
+        const pathArray = path.split('/').slice(1);
+        const curve = new elliptic_1.default.ec('p256');
+        let chainCode = masterKeyHmac.subarray(32, masterKeyHmac.length);
+        let key = masterKeyHmac.subarray(0, 32);
+        for (const stringIdx of pathArray) {
+            let childIdx;
+            let data;
+            if (stringIdx.slice(-1) === "'") {
+                data = Buffer.concat([Buffer.from('00', 'hex'), key]);
+                childIdx = parseInt(stringIdx.slice(0, stringIdx.length - 1), 10) + 0x80000000;
+            }
+            else {
+                const pk = curve.keyFromPrivate(key, 'hex');
+                data = Buffer.from(pk.getPublic().encodeCompressed());
+                childIdx = parseInt(stringIdx, 10);
+            }
+            data = Buffer.concat([data, Buffer.from(childIdx.toString(16).padStart(8, '0'), 'hex')]);
+            const intermediary = crypto_1.default.createHmac('sha512', chainCode).update(data).digest();
+            const k1 = new bignumber_js_1.default(intermediary.subarray(0, 32).toString('hex'), 16);
+            const k2 = new bignumber_js_1.default(key.toString('hex'), 16);
+            const c = new bignumber_js_1.default(curve.n.toString());
+            const protoKey = k1.plus(k2).mod(c).toString(16);
+            key = Buffer.from(protoKey.padStart(64, '0'), 'hex');
+            chainCode = intermediary.slice(32, intermediary.length);
+        }
+        return key.toString('hex');
+    }
+    static generateMnemonic() {
+        return bip39.generateMnemonic(128);
+    }
+    static isValidMnemonic(word) {
+        const wordArray = Array.isArray(word) ? word : word.trim().split(' ');
+        return wordArray.length === 12 || wordArray.length === 24;
+    }
+    static isMnemonic(word) {
+        const wordArray = Array.isArray(word) ? word : word.trim().split(' ');
+        return wordArray.length > 1;
+    }
+    static extractIndexFromPath(bip44Path) {
+        return parseInt(bip44Path.split('/').pop());
+    }
+    static getBip44Path(path, order = 0) {
+        return path.replace('?', order.toString());
+    }
+}
+exports.BSKeychainHelper = BSKeychainHelper;

package/dist/helpers/BSUtilsHelper.d.ts

@@ -1,3 +1,4 @@
+import { TBSNetwork } from '../interfaces';
 type RetryOptions = {
     retries?: number;
     delay?: number;
@@ -6,5 +7,6 @@ type RetryOptions = {
 export declare class BSUtilsHelper {
     static wait(ms: number): Promise<unknown>;
     static retry<T = any>(callback: () => Promise<T>, options?: RetryOptions): Promise<T>;
+    static validateNetwork(network: TBSNetwork, availableNetworks: TBSNetwork[], availableNetworkURLs: string[]): boolean;
 }
 export {};

package/dist/helpers/BSUtilsHelper.js

@@ -8,9 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSUtilsHelper = void 0;
 const error_1 = require("../error");
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
 class BSUtilsHelper {
     static wait(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
@@ -36,5 +40,13 @@ class BSUtilsHelper {
             return reject(new error_1.BSError('Timeout: ' + errorMessage, 'TIMEOUT'));
         }));
     }
+    static validateNetwork(network, availableNetworks, availableNetworkURLs) {
+        const isValid = availableNetworks.some(networkItem => (0, lodash_isequal_1.default)({ id: network.id, type: network.type, name: network.name }, { id: networkItem.id, type: networkItem.type, name: networkItem.name }));
+        if (!isValid)
+            return false;
+        if (!availableNetworkURLs.includes(network.url))
+            return false;
+        return true;
+    }
 }
 exports.BSUtilsHelper = BSUtilsHelper;

package/dist/index.d.ts

@@ -4,9 +4,11 @@ export * from './helpers/BSPromisesHelper';
 export * from './helpers/BSBigNumberHelper';
 export * from './helpers/BSUtilsHelper';
 export * from './helpers/BSAccountHelper';
+export * from './helpers/BSKeychainHelper';
 export * from './services/exchange-data/CryptoCompareEDS';
 export * from './services/exchange-data/FlamingoForthewinEDS';
 export * from './services/token/TokenService';
+export * from './services/nft-data/GhostMarketNDS';
 export * from './functions';
 export * from './interfaces';
 export * from './error';

package/dist/index.js

@@ -20,9 +20,11 @@ __exportStar(require("./helpers/BSPromisesHelper"), exports);
 __exportStar(require("./helpers/BSBigNumberHelper"), exports);
 __exportStar(require("./helpers/BSUtilsHelper"), exports);
 __exportStar(require("./helpers/BSAccountHelper"), exports);
+__exportStar(require("./helpers/BSKeychainHelper"), exports);
 __exportStar(require("./services/exchange-data/CryptoCompareEDS"), exports);
 __exportStar(require("./services/exchange-data/FlamingoForthewinEDS"), exports);
 __exportStar(require("./services/token/TokenService"), exports);
+__exportStar(require("./services/nft-data/GhostMarketNDS"), exports);
 __exportStar(require("./functions"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./error"), exports);