@cityofzion/blockchain-service 0.10.0 → 0.11.1

package/dist/BSAggregator.d.ts

@@ -1,16 +1,16 @@
-import { AccountWithDerivationPath, BlockchainService } from './interfaces';
+import { AccountWithDerivationPath, BlockchainService, Network, PartialBy } from './interfaces';
 export declare class BSAggregator<BSCustomName extends string = string, BSCustom extends BlockchainService<BSCustomName> = BlockchainService<BSCustomName>> {
+    #private;
     readonly blockchainServicesByName: Record<BSCustomName, BSCustom>;
-    readonly blockchainServices: BlockchainService<BSCustomName>[];
     constructor(blockchainServices: Record<BSCustomName, BSCustom>);
+    setNetwork(network: PartialBy<Network, 'url'>): void;
     addBlockchain(name: BSCustomName, blockchain: BSCustom): void;
     validateAddressAllBlockchains(address: string): boolean;
     validateTextAllBlockchains(text: string): boolean;
     validateKeyAllBlockchains(wif: string): boolean;
     validateEncryptedAllBlockchains(keyOrJson: string): boolean;
-    getBlockchainByName(name: BSCustomName): BlockchainService<BSCustomName>;
-    getBlockchainByAddress(address: string): BlockchainService<BSCustomName> | undefined;
-    getBlockchainByKey(wif: string): BlockchainService<BSCustomName> | undefined;
-    getBlockchainByEncrypted(keyOrJson: string): BlockchainService<BSCustomName> | undefined;
+    getBlockchainNameByAddress(address: string): BSCustomName | undefined;
+    getBlockchainNameByKey(wif: string): BSCustomName | undefined;
+    getBlockchainNameByEncrypted(keyOrJson: string): BSCustomName | undefined;
     generateAccountFromMnemonicAllBlockchains(mnemonic: string, skippedAddresses?: string[]): Promise<Map<BSCustomName, AccountWithDerivationPath[]>>;
 }

package/dist/BSAggregator.js

@@ -8,51 +8,63 @@ 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");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BSAggregator_blockchainServices;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSAggregator = void 0;
-const exceptions_1 = require("./exceptions");
 class BSAggregator {
     constructor(blockchainServices) {
+        _BSAggregator_blockchainServices.set(this, void 0);
         this.blockchainServicesByName = blockchainServices;
-        this.blockchainServices = Object.values(blockchainServices);
+        __classPrivateFieldSet(this, _BSAggregator_blockchainServices, Object.values(blockchainServices), "f");
+    }
+    setNetwork(network) {
+        __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").forEach(bs => bs.setNetwork(network));
     }
     addBlockchain(name, blockchain) {
         if (this.blockchainServicesByName[name])
-            throw new exceptions_1.BlockchainAlreadyExistError(name);
+            throw new Error(`The blockchain ${name} already exist`);
         this.blockchainServicesByName[name] = blockchain;
-        this.blockchainServices.push(blockchain);
+        __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").push(blockchain);
     }
     validateAddressAllBlockchains(address) {
-        return this.blockchainServices.some(bs => bs.validateAddress(address));
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateAddress(address));
     }
     validateTextAllBlockchains(text) {
-        return this.blockchainServices.some(bs => [bs.validateAddress(text), bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => [bs.validateAddress(text), bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
     }
     validateKeyAllBlockchains(wif) {
-        return this.blockchainServices.some(bs => bs.validateKey(wif));
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateKey(wif));
     }
     validateEncryptedAllBlockchains(keyOrJson) {
-        return this.blockchainServices.some(bs => bs.validateEncrypted(keyOrJson));
-    }
-    getBlockchainByName(name) {
-        const service = this.blockchainServicesByName[name];
-        if (!service)
-            throw new exceptions_1.BlockchainNotFoundError(name);
-        return this.blockchainServicesByName[name];
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateEncrypted(keyOrJson));
     }
-    getBlockchainByAddress(address) {
-        return this.blockchainServices.find(bs => bs.validateAddress(address));
+    getBlockchainNameByAddress(address) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").find(bs => bs.validateAddress(address))) === null || _a === void 0 ? void 0 : _a.blockchainName;
     }
-    getBlockchainByKey(wif) {
-        return this.blockchainServices.find(bs => bs.validateKey(wif));
+    getBlockchainNameByKey(wif) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").find(bs => bs.validateKey(wif))) === null || _a === void 0 ? void 0 : _a.blockchainName;
     }
-    getBlockchainByEncrypted(keyOrJson) {
-        return this.blockchainServices.find(bs => bs.validateEncrypted(keyOrJson));
+    getBlockchainNameByEncrypted(keyOrJson) {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").find(bs => bs.validateEncrypted(keyOrJson))) === null || _a === void 0 ? void 0 : _a.blockchainName;
     }
     generateAccountFromMnemonicAllBlockchains(mnemonic, skippedAddresses) {
         return __awaiter(this, void 0, void 0, function* () {
             const mnemonicAccounts = new Map();
-            const promises = this.blockchainServices.map((service) => __awaiter(this, void 0, void 0, function* () {
+            const promises = __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").map((service) => __awaiter(this, void 0, void 0, function* () {
                 let index = 0;
                 const accounts = [];
                 let hasError = false;
@@ -85,3 +97,4 @@ class BSAggregator {
     }
 }
 exports.BSAggregator = BSAggregator;
+_BSAggregator_blockchainServices = new WeakMap();

package/dist/interfaces.d.ts

@@ -25,19 +25,13 @@ export type IntentTransferParam = {
     amount: string;
     tokenDecimals?: number;
 };
-export type TransferParamWithLedger = {
-    isLedger: true;
-    ledgerTransport: Transport;
-};
-export type TransferParamWithoutLedger = {
-    isLedger?: false;
-};
 export type TransferParam = {
     senderAccount: Account;
     intent: IntentTransferParam;
     tipIntent?: IntentTransferParam;
     priorityFee?: string;
-} & (TransferParamWithLedger | TransferParamWithoutLedger);
+    isLedger?: boolean;
+};
 export type TokenPricesResponse = {
     price: number;
     symbol: string;
@@ -72,7 +66,7 @@ export interface BSClaimable {
     readonly claimToken: Token;
     readonly burnToken: Token;
     blockchainDataService: BlockchainDataService & BDSClaimable;
-    claim(account: Account): Promise<string>;
+    claim(account: Account, isLedger?: boolean): Promise<string>;
 }
 export interface BSWithNameService {
     resolveNameServiceDomain(domainName: string): Promise<string>;
@@ -144,6 +138,11 @@ export type BalanceResponse = {
     amount: string;
     token: Token;
 };
+export type RpcResponse = {
+    latency: number;
+    url: string;
+    height: number;
+};
 export interface BlockchainDataService {
     maxTimeToConfirmTransactionInMs: number;
     getTransaction(txid: string): Promise<TransactionResponse>;
@@ -152,6 +151,7 @@ export interface BlockchainDataService {
     getTokenInfo(tokenHash: string): Promise<Token>;
     getBalance(address: string): Promise<BalanceResponse[]>;
     getBlockHeight(): Promise<number>;
+    getRpcList(): Promise<RpcResponse[]>;
 }
 export interface BDSClaimable {
     getUnclaimed(address: string): Promise<string>;
@@ -198,6 +198,7 @@ export interface ExplorerService {
     buildNftUrl(params: BuildNftUrlParams): string;
 }
 export interface LedgerService {
+    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.10.0",
+  "version": "0.11.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",

package/dist/exceptions.d.ts

@@ -1,9 +0,0 @@
-export declare class BlockchainAlreadyExistError extends Error {
-    constructor(blockchainName: string);
-}
-export declare class InvalidBlockchainServiceError extends Error {
-    constructor(message?: string);
-}
-export declare class BlockchainNotFoundError extends Error {
-    constructor(blockchainName: string);
-}

package/dist/exceptions.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlockchainNotFoundError = exports.InvalidBlockchainServiceError = exports.BlockchainAlreadyExistError = void 0;
-class BlockchainAlreadyExistError extends Error {
-    constructor(blockchainName) {
-        super(`The blockchain ${blockchainName} already exist`);
-    }
-}
-exports.BlockchainAlreadyExistError = BlockchainAlreadyExistError;
-class InvalidBlockchainServiceError extends Error {
-    constructor(message) {
-        super(`Invalid blockchainServices => ${message}`);
-    }
-}
-exports.InvalidBlockchainServiceError = InvalidBlockchainServiceError;
-class BlockchainNotFoundError extends Error {
-    constructor(blockchainName) {
-        super(`The blockchain ${blockchainName} not found`);
-    }
-}
-exports.BlockchainNotFoundError = BlockchainNotFoundError;