@cityofzion/blockchain-service 0.7.3 → 0.8.0

package/dist/BSAggregator.d.ts

@@ -1,16 +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[]>>;
-}
+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

@@ -1,86 +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;
+"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,9 +1,9 @@
-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);
-}
+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 +1,21 @@
-"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;
+"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;

package/dist/functions.d.ts

@@ -1,7 +1,7 @@
-import { BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, 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 waitForTransaction(service: BlockchainService, txId: string): Promise<boolean>;
+import { BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, 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 waitForTransaction(service: BlockchainService, txId: string): Promise<boolean>;

package/dist/functions.js

@@ -1,53 +1,53 @@
-"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.waitForTransaction = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
-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 wait(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-function waitForTransaction(service, txId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const maxAttempts = 30;
-        const waitMs = service.blockchainDataService.maxTimeToConfirmTransactionInMs / maxAttempts;
-        let attempts = 1;
-        do {
-            try {
-                yield service.blockchainDataService.getTransaction(txId);
-                return true;
-            }
-            catch (_a) { }
-            attempts++;
-            yield wait(waitMs);
-        } while (attempts < maxAttempts);
-        return false;
-    });
-}
-exports.waitForTransaction = waitForTransaction;
+"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.waitForTransaction = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+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 wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function waitForTransaction(service, txId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const maxAttempts = 30;
+        const waitMs = service.blockchainDataService.maxTimeToConfirmTransactionInMs / maxAttempts;
+        let attempts = 1;
+        do {
+            try {
+                yield service.blockchainDataService.getTransaction(txId);
+                return true;
+            }
+            catch (_a) { }
+            attempts++;
+            yield wait(waitMs);
+        } while (attempts < maxAttempts);
+        return false;
+    });
+}
+exports.waitForTransaction = waitForTransaction;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,19 +1,19 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./interfaces"), exports);
-__exportStar(require("./BSAggregator"), exports);
-__exportStar(require("./functions"), exports);
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./BSAggregator"), exports);
+__exportStar(require("./functions"), exports);

package/dist/interfaces.d.ts

@@ -1,181 +1,182 @@
-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 AccountWithDerivationPath = Account & {
-    derivationPath: string;
-};
-export interface Token {
-    symbol: string;
-    name: string;
-    hash: string;
-    decimals: number;
-}
-export type NetworkType = 'mainnet' | 'testnet' | 'custom';
-export type Network = {
-    type: NetworkType;
-    url: 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 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 blockchainName: BSCustomName;
-    readonly derivationPath: string;
-    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;
-    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 BSWithExplorerService {
-    explorerService: ExplorerService;
-}
-export interface BSWithNft {
-    nftDataService: NftDataService;
-}
-export type TransactionNotifications = {
-    eventName: string;
-    state: {
-        type: string;
-        value: string;
-    }[];
-};
-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;
-    block: number;
-    time: number;
-    transfers: (TransactionTransferAsset | TransactionTransferNft)[];
-    fee?: string;
-    notifications: TransactionNotifications[];
-};
-export type ContractParameter = {
-    name: string;
-    type: string;
-};
-export type TransactionsByAddressResponse = {
-    totalCount: number;
-    limit: number;
-    transactions: TransactionResponse[];
-};
-export type TransactionsByAddressParams = {
-    address: string;
-    page?: number;
-};
-export type ContractMethod = {
-    name: string;
-    parameters: ContractParameter[];
-};
-export type ContractResponse = {
-    hash: string;
-    name: string;
-    methods: ContractMethod[];
-};
-export type BalanceResponse = {
-    amount: string;
-    token: Token;
-};
-export interface BlockchainDataService {
-    maxTimeToConfirmTransactionInMs: number;
-    getTransaction(txid: string): Promise<TransactionResponse>;
-    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
-    getContract(contractHash: string): Promise<ContractResponse>;
-    getTokenInfo(tokenHash: string): Promise<Token>;
-    getBalance(address: string): Promise<BalanceResponse[]>;
-    getBlockHeight(): Promise<number>;
-}
-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 NftDataService {
-    getNftsByAddress(params: GetNftsByAddressParams): Promise<NftsResponse>;
-    getNft(params: GetNftParam): Promise<NftResponse>;
-}
-export type BuildNftUrlParams = {
-    contractHash: string;
-    tokenId: string;
-};
-export interface ExplorerService {
-    buildTransactionUrl(hash: string): string;
-    buildNftUrl(params: BuildNftUrlParams): 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 AccountWithDerivationPath = Account & {
+    derivationPath: string;
+};
+export interface Token {
+    symbol: string;
+    name: string;
+    hash: string;
+    decimals: number;
+}
+export type NetworkType = 'mainnet' | 'testnet' | 'custom';
+export type Network = {
+    type: NetworkType;
+    url: 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 TokenPricesResponse = {
+    price: number;
+    symbol: string;
+    hash: string;
+};
+export type Currency = 'USD' | 'BRL' | 'EUR';
+export interface ExchangeDataService {
+    getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]>;
+}
+export interface BlockchainService<BSCustomName extends string = string> {
+    readonly blockchainName: BSCustomName;
+    readonly derivationPath: string;
+    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;
+    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 BSWithExplorerService {
+    explorerService: ExplorerService;
+}
+export interface BSWithNft {
+    nftDataService: NftDataService;
+}
+export type TransactionNotifications = {
+    eventName: string;
+    state: {
+        type: string;
+        value: string;
+    }[];
+};
+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;
+    block: number;
+    time: number;
+    transfers: (TransactionTransferAsset | TransactionTransferNft)[];
+    fee?: string;
+    notifications: TransactionNotifications[];
+};
+export type ContractParameter = {
+    name: string;
+    type: string;
+};
+export type TransactionsByAddressResponse = {
+    totalCount: number;
+    limit: number;
+    transactions: TransactionResponse[];
+};
+export type TransactionsByAddressParams = {
+    address: string;
+    page?: number;
+};
+export type ContractMethod = {
+    name: string;
+    parameters: ContractParameter[];
+};
+export type ContractResponse = {
+    hash: string;
+    name: string;
+    methods: ContractMethod[];
+};
+export type BalanceResponse = {
+    amount: string;
+    token: Token;
+};
+export interface BlockchainDataService {
+    maxTimeToConfirmTransactionInMs: number;
+    getTransaction(txid: string): Promise<TransactionResponse>;
+    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
+    getContract(contractHash: string): Promise<ContractResponse>;
+    getTokenInfo(tokenHash: string): Promise<Token>;
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    getBlockHeight(): Promise<number>;
+}
+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 NftDataService {
+    getNftsByAddress(params: GetNftsByAddressParams): Promise<NftsResponse>;
+    getNft(params: GetNftParam): Promise<NftResponse>;
+}
+export type BuildNftUrlParams = {
+    contractHash: string;
+    tokenId: string;
+};
+export interface ExplorerService {
+    buildTransactionUrl(hash: string): string;
+    buildNftUrl(params: BuildNftUrlParams): string;
+}

package/dist/interfaces.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,21 +1,20 @@
-{
-  "name": "@cityofzion/blockchain-service",
-  "version": "0.7.3",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "repository": "https://github.com/CityOfZion/blockchain-services",
-  "author": "Coz",
-  "license": "MIT",
-  "files": [
-    "/dist"
-  ],
-  "scripts": {
-    "build": "tsc && typedoc"
-  },
-  "devDependencies": {
-    "@types/node": "~20.2.5",
-    "ts-node": "10.9.1",
-    "typescript": "4.9.5",
-    "typedoc": "0.23.24"
-  }
+{
+  "name": "@cityofzion/blockchain-service",
+  "version": "0.8.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": "https://github.com/CityOfZion/blockchain-services",
+  "author": "Coz",
+  "license": "MIT",
+  "files": [
+    "/dist"
+  ],
+  "devDependencies": {
+    "@types/node": "~20.2.5",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
 }

package/dist/BSAgreggator.d.ts

@@ -1,16 +0,0 @@
-import { BlockchainService, Claimable } from "./interfaces";
-export declare class BSAgreggator<BSCustom extends BlockchainService = BlockchainService, BSCustomName extends string = string> {
-    readonly blockchainservices: Record<BSCustomName, BSCustom>;
-    private bsList;
-    constructor(blockchainservices: Record<BSCustomName, BSCustom>);
-    private haveBlockchainServices;
-    addBlockchain(name: BSCustomName, blockchain: BSCustom): void;
-    validateAddressesAllBlockchains(address: string): boolean;
-    validateTextAllBlockchains(text: string): boolean;
-    validateWifAllBlockchains(wif: string): boolean;
-    validateEncryptedKeyAllBlockchains(encryptedKey: string): boolean;
-    getBlockchainByAddress(address: string): BlockchainService<BSCustomName> | null;
-    getBlockchainByWif(wif: string): BlockchainService<BSCustomName> | null;
-    getBlockchainByEncryptedKey(encryptedKey: string): BlockchainService<BSCustomName> | null;
-    getBlockchainsClaimable(): (BlockchainService<BSCustomName> & Claimable)[];
-}

package/dist/BSAgreggator.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BSAgreggator = void 0;
-const exceptions_1 = require("./exceptions");
-class BSAgreggator {
-    constructor(blockchainservices) {
-        this.blockchainservices = blockchainservices;
-        this.bsList = Object.values(blockchainservices);
-    }
-    haveBlockchainServices() {
-        const blockchainservices = Object.values(this.blockchainservices);
-        const rules = [
-            Object.keys(blockchainservices).length > 1,
-            Object.values(blockchainservices).length > 1,
-        ];
-        return rules.every(rule => rule === true);
-    }
-    addBlockchain(name, blockchain) {
-        if (this.blockchainservices[name])
-            exceptions_1.exceptions.blockchainAlreadyExist(name);
-        this.blockchainservices[name] = blockchain;
-        this.bsList = Object.values(this.blockchainservices);
-    }
-    validateAddressesAllBlockchains(address) {
-        if (this.haveBlockchainServices())
-            exceptions_1.exceptions.invalidBlockchainService(JSON.stringify(this.blockchainservices));
-        return this.bsList.some(bs => bs.validateAddress(address));
-    }
-    validateTextAllBlockchains(text) {
-        if (this.haveBlockchainServices())
-            exceptions_1.exceptions.invalidBlockchainService(JSON.stringify(this.blockchainservices));
-        return this.bsList.some(bs => [bs.validateAddress(text), bs.validateEncryptedKey(text), bs.validateWif(text)].some(it => it === true));
-    }
-    validateWifAllBlockchains(wif) {
-        if (this.haveBlockchainServices())
-            exceptions_1.exceptions.invalidBlockchainService(JSON.stringify(this.blockchainservices));
-        return this.bsList.some(bs => bs.validateWif(wif));
-    }
-    validateEncryptedKeyAllBlockchains(encryptedKey) {
-        if (this.haveBlockchainServices())
-            exceptions_1.exceptions.invalidBlockchainService(JSON.stringify(this.blockchainservices));
-        return this.bsList.some(bs => bs.validateEncryptedKey(encryptedKey));
-    }
-    getBlockchainByAddress(address) {
-        var _a;
-        if (this.haveBlockchainServices())
-            exceptions_1.exceptions.invalidBlockchainService(JSON.stringify(this.blockchainservices));
-        return (_a = this.bsList.find(bs => bs.validateAddress(address))) !== null && _a !== void 0 ? _a : null;
-    }
-    getBlockchainByWif(wif) {
-        var _a;
-        if (this.haveBlockchainServices())
-            exceptions_1.exceptions.invalidBlockchainService(JSON.stringify(this.blockchainservices));
-        return (_a = this.bsList.find(bs => bs.validateWif(wif))) !== null && _a !== void 0 ? _a : null;
-    }
-    getBlockchainByEncryptedKey(encryptedKey) {
-        var _a;
-        if (this.haveBlockchainServices())
-            exceptions_1.exceptions.invalidBlockchainService(JSON.stringify(this.blockchainservices));
-        return (_a = this.bsList.find(bs => bs.validateEncryptedKey(encryptedKey))) !== null && _a !== void 0 ? _a : null;
-    }
-    getBlockchainsClaimable() {
-        const methodName = { claim: 'claim', getUnclaimed: 'getUnclaimed', tokenClaim: 'tokenClaim' };
-        const claimableBlockchains = this.bsList.filter(blockchain => methodName.claim in blockchain &&
-            methodName.getUnclaimed in blockchain.dataService &&
-            methodName.tokenClaim in blockchain);
-        return claimableBlockchains;
-    }
-}
-exports.BSAgreggator = BSAgreggator;

package/dist/exchanges/flamingo/Flamingo.d.ts

@@ -1,8 +0,0 @@
-import { Currency, Exchange } from '../../interfaces';
-export declare class Flamingo implements Exchange {
-    private request;
-    getTokenPrices(currency: Currency): Promise<{
-        amount: number;
-        Symbol: string;
-    }[]>;
-}

package/dist/exchanges/flamingo/Flamingo.js

@@ -1,37 +0,0 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Flamingo = void 0;
-const axios_1 = __importDefault(require("axios"));
-const FlamingoRoutes_1 = require("./FlamingoRoutes");
-class Flamingo {
-    constructor() {
-        this.request = axios_1.default.create({ baseURL: 'https://api.flamingo.finance' });
-    }
-    getTokenPrices(currency) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { data: prices } = yield this.request.get(`/${FlamingoRoutes_1.FLAMINGO_TOKENINFO_PRICES}`);
-            let currencyRatio = 1;
-            if (currency !== 'USD') {
-                const { data } = yield this.request.get(`/${(0, FlamingoRoutes_1.FLAMINGO_FIAT_EXCHANGE_RATE)('USD', currency)}`);
-                currencyRatio = data;
-            }
-            return prices.map(price => ({
-                amount: price.usd_price * currencyRatio,
-                Symbol: price.symbol
-            }));
-        });
-    }
-}
-exports.Flamingo = Flamingo;

package/dist/exchanges/flamingo/FlamingoResponses.d.ts

@@ -1,4 +0,0 @@
-export type FlamingoTokenInfoPricesResponse = {
-    symbol: string;
-    usd_price: number;
-}[];

package/dist/exchanges/flamingo/FlamingoResponses.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/exchanges/flamingo/FlamingoRoutes.d.ts

@@ -1,3 +0,0 @@
-import { Currency } from "../../interfaces";
-export declare const FLAMINGO_TOKENINFO_PRICES = "token-info/prices";
-export declare const FLAMINGO_FIAT_EXCHANGE_RATE: (currencyFrom: Currency, currencyTo: Currency) => string;

package/dist/exchanges/flamingo/FlamingoRoutes.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FLAMINGO_FIAT_EXCHANGE_RATE = exports.FLAMINGO_TOKENINFO_PRICES = void 0;
-exports.FLAMINGO_TOKENINFO_PRICES = 'token-info/prices';
-const FLAMINGO_FIAT_EXCHANGE_RATE = (currencyFrom, currencyTo) => {
-    return `fiat/exchange-rate?pair=${currencyFrom}_${currencyTo}`;
-};
-exports.FLAMINGO_FIAT_EXCHANGE_RATE = FLAMINGO_FIAT_EXCHANGE_RATE;

package/dist/exchanges/index.d.ts

@@ -1,7 +0,0 @@
-export * from './flamingo/Flamingo';
-export * from './flamingo/FlamingoResponses';
-export * from './flamingo/FlamingoRoutes';
-import { Flamingo } from "./flamingo/Flamingo";
-export declare const exchangeOptions: {
-    flamingo: Flamingo;
-};

package/dist/exchanges/index.js

@@ -1,24 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exchangeOptions = void 0;
-__exportStar(require("./flamingo/Flamingo"), exports);
-__exportStar(require("./flamingo/FlamingoResponses"), exports);
-__exportStar(require("./flamingo/FlamingoRoutes"), exports);
-const Flamingo_1 = require("./flamingo/Flamingo");
-exports.exchangeOptions = {
-    flamingo: new Flamingo_1.Flamingo()
-};