@cityofzion/blockchain-service 0.7.0 → 0.7.2

package/dist/BSAggregator.d.ts

@@ -0,0 +1,16 @@
+import { AccountWithDerivationPath, BlockchainService } from './interfaces';
+export declare class BSAggregator<BSCustomName extends string = string, BSCustom extends BlockchainService<BSCustomName> = BlockchainService<BSCustomName>> {
+    readonly blockchainServicesByName: Record<BSCustomName, BSCustom>;
+    readonly blockchainServices: BlockchainService<BSCustomName>[];
+    constructor(blockchainServices: Record<BSCustomName, BSCustom>);
+    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;
+    generateAccountFromMnemonicAllBlockchains(mnemonic: string, skippedAddresses?: string[]): Promise<Map<BSCustomName, AccountWithDerivationPath[]>>;
+}

package/dist/BSAggregator.js

@@ -0,0 +1,86 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSAggregator = void 0;
+const exceptions_1 = require("./exceptions");
+class BSAggregator {
+    constructor(blockchainServices) {
+        this.blockchainServicesByName = blockchainServices;
+        this.blockchainServices = Object.values(blockchainServices);
+    }
+    addBlockchain(name, blockchain) {
+        if (this.blockchainServicesByName[name])
+            throw new exceptions_1.BlockchainAlreadyExistError(name);
+        this.blockchainServicesByName[name] = blockchain;
+        this.blockchainServices.push(blockchain);
+    }
+    validateAddressAllBlockchains(address) {
+        return this.blockchainServices.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));
+    }
+    validateKeyAllBlockchains(wif) {
+        return this.blockchainServices.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];
+    }
+    getBlockchainByAddress(address) {
+        return this.blockchainServices.find(bs => bs.validateAddress(address));
+    }
+    getBlockchainByKey(wif) {
+        return this.blockchainServices.find(bs => bs.validateKey(wif));
+    }
+    getBlockchainByEncrypted(keyOrJson) {
+        return this.blockchainServices.find(bs => bs.validateEncrypted(keyOrJson));
+    }
+    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* () {
+                let index = 0;
+                const accounts = [];
+                while (true) {
+                    const generatedAccount = service.generateAccountFromMnemonic(mnemonic, index);
+                    if (skippedAddresses && skippedAddresses.find(address => address === generatedAccount.address)) {
+                        index++;
+                        continue;
+                    }
+                    if (index !== 0) {
+                        try {
+                            const { totalCount } = yield service.blockchainDataService.getTransactionsByAddress({
+                                address: generatedAccount.address,
+                            });
+                            if (!totalCount || totalCount <= 0)
+                                break;
+                        }
+                        catch (_a) {
+                            break;
+                        }
+                    }
+                    accounts.push(generatedAccount);
+                    index++;
+                }
+                mnemonicAccounts.set(service.blockchainName, accounts);
+            }));
+            yield Promise.all(promises);
+            return mnemonicAccounts;
+        });
+    }
+}
+exports.BSAggregator = BSAggregator;

package/dist/exceptions.d.ts

@@ -1,4 +1,9 @@
-export declare const exceptions: {
-    invalidBlockchainService: (message?: string) => never;
-    blockchainAlreadyExist: (blockchainName: string) => never;
-};
+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,11 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exceptions = void 0;
-exports.exceptions = {
-    invalidBlockchainService: (message) => {
-        throw new Error(`Invalid blockchainServices => ${message}`);
-    },
-    blockchainAlreadyExist: (blockchainName) => {
-        throw new Error(`The blockchain ${blockchainName} already exist`);
+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;

package/dist/functions.d.ts

@@ -1,3 +1,5 @@
-import { BlockchainService, Claimable, NeoNameService } from "./interfaces";
-export declare function hasNNS(service: BlockchainService): service is NeoNameService & BlockchainService;
-export declare function isClaimable(service: BlockchainService): service is Claimable & BlockchainService;
+import { BlockchainService, BSCalculableFee, BSClaimable, 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;

package/dist/functions.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClaimable = exports.hasNNS = void 0;
-function hasNNS(service) {
-    return "getNeoNsRecord" in service && "getOwnerOfNeoNsRecord" in service && "validateNNSDomain" in service;
+exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+function hasNameService(service) {
+    return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
 }
-exports.hasNNS = hasNNS;
+exports.hasNameService = hasNameService;
 function isClaimable(service) {
-    return "claim" in this && "tokenClaim" in this && "getUnclaimed" in this.dataService;
+    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;

package/dist/index.d.ts

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

package/dist/index.js

@@ -15,6 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./interfaces"), exports);
-__exportStar(require("./BSAgreggator"), exports);
-__exportStar(require("./exchanges"), exports);
+__exportStar(require("./BSAggregator"), exports);
 __exportStar(require("./functions"), exports);

package/dist/interfaces.d.ts

@@ -1,116 +1,119 @@
-export type SendTransactionParam = {
-    senderAccount: Account;
-    transactionIntents: IntentTransactionParam[];
-    priorityFee?: number;
-};
-export type IntentTransactionParam = {
-    receiverAddress: string;
-    tokenHash: string;
-    amount: number;
-};
-export type CalculateTransferFeeDetails = {
-    systemFee?: string;
-    networkFee?: string;
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Account = {
+    key: string;
+    type: 'wif' | 'privateKey';
+    address: string;
 };
-export type Currency = "USD" | "BRL" | "EUR";
-export type ExchangeInfo = {
-    symbol: string;
-    amount: number;
+export type AccountWithDerivationPath = Account & {
+    derivationPath: string;
 };
-export type ClaimResponse = {
-    txid: string;
+export interface Token {
     symbol: string;
-    hash: string;
-};
-export interface Claimable {
-    claim(account: Account): Promise<ClaimResponse>;
-    dataService: BlockchainDataService & BDSClaimable;
-    tokenClaim: {
-        hash: string;
-        symbol: string;
-        decimals: number;
-    };
-}
-export declare enum NNSRecordTypes {
-    IPV4 = "1",
-    CANONICAL_NAME = "5",
-    TEXT = "16",
-    IPV6 = "28"
-}
-export interface NeoNameService {
-    getNNSRecord(domainName: string, type: NNSRecordTypes): Promise<string>;
-    getOwnerOfNNS(domainName: string): Promise<string>;
-    validateNNSFormat(domainName: string): boolean;
-}
-export type Token = {
     name: string;
-    symbol: string;
     hash: string;
     decimals: number;
+}
+export type NetworkType = 'mainnet' | 'testnet' | 'custom';
+export type Network = {
+    type: NetworkType;
+    url: string;
 };
-export type Account = {
-    wif: string;
-    address: string;
+export type IntentTransferParam = {
+    receiverAddress: string;
+    tokenHash: string;
+    amount: string;
+    tokenDecimals?: number;
+};
+export type TransferParam = {
+    senderAccount: Account;
+    intent: IntentTransferParam;
+    tipIntent?: IntentTransferParam;
+    priorityFee?: string;
 };
-export type CalculateTransferFeeResponse = {
-    result: number;
-    details?: CalculateTransferFeeDetails;
+export type TokenPricesResponse = {
+    price: number;
+    symbol: string;
 };
+export type Currency = 'USD' | 'BRL' | 'EUR';
+export interface ExchangeDataService {
+    getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]>;
+}
 export interface BlockchainService<BSCustomName extends string = string> {
-    readonly dataService: BlockchainDataService;
     readonly blockchainName: BSCustomName;
     readonly derivationPath: string;
-    readonly feeToken: {
-        hash: string;
-        symbol: string;
-        decimals: number;
-    };
-    readonly exchange: Exchange;
-    readonly tokens: Token[];
-    sendTransaction(param: SendTransactionParam): Promise<string>;
-    generateMnemonic(): string;
-    generateWif(mnemonic: string, index: number): string;
-    generateAccount(mnemonic: string, index: number): Account;
-    generateAccountFromWif(wif: string): string;
-    decryptKey(encryptedKey: string, password: string): Promise<Account>;
+    readonly feeToken: Token;
+    exchangeDataService: ExchangeDataService;
+    blockchainDataService: BlockchainDataService;
+    tokens: Token[];
+    network: Network;
+    setNetwork: (network: PartialBy<Network, 'url'>) => void;
+    generateAccountFromMnemonic(mnemonic: string | string, index: number): AccountWithDerivationPath;
+    generateAccountFromKey(key: string): Account;
+    decrypt(keyOrJson: string, password: string): Promise<Account>;
     validateAddress(address: string): boolean;
-    validateEncryptedKey(encryptedKey: string): boolean;
-    validateWif(wif: string): boolean;
-    calculateTransferFee(param: SendTransactionParam, details?: boolean): Promise<CalculateTransferFeeResponse>;
+    validateEncrypted(keyOrJson: string): boolean;
+    validateKey(key: string): boolean;
+    transfer(param: TransferParam): Promise<string>;
+}
+export interface BSCalculableFee {
+    calculateTransferFee(param: TransferParam, details?: boolean): Promise<string>;
+}
+export interface BSClaimable {
+    readonly claimToken: Token;
+    readonly burnToken: Token;
+    blockchainDataService: BlockchainDataService & BDSClaimable;
+    claim(account: Account): Promise<string>;
+}
+export interface BSWithNameService {
+    resolveNameServiceDomain(domainName: string): Promise<string>;
+    validateNameServiceDomainFormat(domainName: string): boolean;
+}
+export interface BSWithNft {
+    nftDataService: NftDataService;
 }
 export type TransactionNotifications = {
-    contract: string;
-    event_name: string;
+    eventName: string;
     state: {
         type: string;
         value: string;
     }[];
 };
-export type TransactionResponse = {
-    txid: string;
-    block: number;
-    time: string;
-    transfers: Omit<TransactionTransfer, 'txid'>[];
-    sysfee: string;
-    netfee: string;
-    totfee: string;
-    notifications: TransactionNotifications[];
-};
-export type TransactionTransfer = {
+export type TransactionTransferAsset = {
     amount: string;
     to: string;
     from: string;
+    type: 'token';
+    contractHash: string;
+    token?: Token;
+};
+export type TransactionTransferNft = {
+    tokenId: string;
+    to: string;
+    from: string;
+    type: 'nft';
+    contractHash: string;
+};
+export type TransactionResponse = {
     hash: string;
-    txid: string;
+    block: number;
+    time: number;
+    transfers: (TransactionTransferAsset | TransactionTransferNft)[];
+    fee?: string;
+    notifications: TransactionNotifications[];
 };
 export type ContractParameter = {
     name: string;
     type: string;
 };
-export type TransactionHistoryResponse = {
+export type TransactionsByAddressResponse = {
     totalCount: number;
+    limit: number;
     transactions: TransactionResponse[];
 };
+export type TransactionsByAddressParams = {
+    address: string;
+    page?: number;
+};
 export type ContractMethod = {
     name: string;
     parameters: ContractParameter[];
@@ -120,44 +123,47 @@ export type ContractResponse = {
     name: string;
     methods: ContractMethod[];
 };
-export type ConsensusNodeResponse = {
-    url: string;
-    height: number;
-};
-export type TokenInfoResponse = {
-    symbol: string;
-    decimals: number;
-};
-export type BlockchainNetwork = "mainnet" | "testnet" | "privatenet";
 export type BalanceResponse = {
-    amount: number;
-    hash: string;
-    symbol: string;
-    name: string;
-};
-export type UnclaimedResponse = {
-    address: string;
-    unclaimed: number;
+    amount: string;
+    token: Token;
 };
-export interface BDSClaimable {
-    getUnclaimed(address: string): Promise<UnclaimedResponse>;
-}
 export interface BlockchainDataService {
-    readonly explorer: string;
-    network: BlockchainNetwork;
-    setNetwork(network: BlockchainNetwork): void;
     getTransaction(txid: string): Promise<TransactionResponse>;
-    getHistoryTransactions(address: string, page: number): Promise<TransactionHistoryResponse>;
+    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
     getContract(contractHash: string): Promise<ContractResponse>;
-    getTokenInfo(tokenHash: string): Promise<TokenInfoResponse>;
+    getTokenInfo(tokenHash: string): Promise<Token>;
     getBalance(address: string): Promise<BalanceResponse[]>;
-    getAllNodes(): Promise<ConsensusNodeResponse[]>;
-    getHigherNode(): Promise<ConsensusNodeResponse>;
+    getBlockHeight(): Promise<number>;
 }
-export type ToeknPricesResponse = {
-    amount: number;
-    Symbol: string;
+export interface BDSClaimable {
+    getUnclaimed(address: string): Promise<string>;
+}
+export interface NftResponse {
+    id: string;
+    contractHash: string;
+    collectionName?: string;
+    collectionImage?: string;
+    symbol: string;
+    image?: string;
+    name?: string;
+    isSVG?: boolean;
+}
+export interface NftsResponse {
+    items: NftResponse[];
+    nextCursor?: string;
+    total?: number;
+}
+export type GetNftsByAddressParams = {
+    address: string;
+    page?: number;
+    cursor?: string;
+    size?: number;
+};
+export type GetNftParam = {
+    tokenId: string;
+    contractHash: string;
 };
-export interface Exchange {
-    getTokenPrices(currency: Currency): Promise<ToeknPricesResponse[]>;
+export interface NftDataService {
+    getNftsByAddress(params: GetNftsByAddressParams): Promise<NftsResponse>;
+    getNft(params: GetNftParam): Promise<NftResponse>;
 }

package/dist/interfaces.js

@@ -1,11 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NNSRecordTypes = void 0;
-var NNSRecordTypes;
-(function (NNSRecordTypes) {
-    NNSRecordTypes["IPV4"] = "1";
-    NNSRecordTypes["CANONICAL_NAME"] = "5";
-    NNSRecordTypes["TEXT"] = "16";
-    NNSRecordTypes["IPV6"] = "28";
-})(NNSRecordTypes = exports.NNSRecordTypes || (exports.NNSRecordTypes = {}));
-//*****************************************************************************

package/package.json

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