@cityofzion/blockchain-service 0.9.1 → 0.11.0

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/functions.d.ts

@@ -1,7 +1,8 @@
-import { BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithNameService, BSWithNft } from './interfaces';
+import { BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft } from './interfaces';
 export declare function hasNameService(service: BlockchainService): service is BlockchainService & BSWithNameService;
 export declare function isClaimable(service: BlockchainService): service is BlockchainService & BSClaimable;
 export declare function isCalculableFee(service: BlockchainService): service is BlockchainService & BSCalculableFee;
 export declare function hasNft(service: BlockchainService): service is BlockchainService & BSWithNft;
 export declare function hasExplorerService(service: BlockchainService): service is BlockchainService & BSWithExplorerService;
+export declare function hasLedger(service: BlockchainService): service is BlockchainService & BSWithLedger;
 export declare function waitForTransaction(service: BlockchainService, txId: string): Promise<boolean>;

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.waitForTransaction = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+exports.waitForTransaction = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
 function hasNameService(service) {
     return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
 }
@@ -30,6 +30,10 @@ function hasExplorerService(service) {
     return 'explorerService' in service;
 }
 exports.hasExplorerService = hasExplorerService;
+function hasLedger(service) {
+    return 'ledgerService' in service;
+}
+exports.hasLedger = hasLedger;
 function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }

package/dist/interfaces.d.ts

@@ -1,7 +1,8 @@
+import Transport from '@ledgerhq/hw-transport';
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type Account = {
     key: string;
-    type: 'wif' | 'privateKey';
+    type: 'wif' | 'privateKey' | 'publicKey';
     address: string;
 };
 export type AccountWithDerivationPath = Account & {
@@ -29,6 +30,7 @@ export type TransferParam = {
     intent: IntentTransferParam;
     tipIntent?: IntentTransferParam;
     priorityFee?: string;
+    isLedger?: boolean;
 };
 export type TokenPricesResponse = {
     price: number;
@@ -64,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>;
@@ -76,6 +78,10 @@ export interface BSWithExplorerService {
 export interface BSWithNft {
     nftDataService: NftDataService;
 }
+export interface BSWithLedger {
+    ledgerService: LedgerService;
+    generateAccountFromPublicKey(publicKey: string): Account;
+}
 export type TransactionNotifications = {
     eventName: string;
     state: {
@@ -185,3 +191,8 @@ export interface ExplorerService {
     buildTransactionUrl(hash: string): string;
     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.9.1",
+  "version": "0.11.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -17,6 +17,9 @@
     "ts-node": "10.9.1",
     "typescript": "4.9.5"
   },
+  "dependencies": {
+    "@ledgerhq/hw-transport": "~6.30.5"
+  },
   "scripts": {
     "build": "tsc",
     "lint": "eslint .",

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;