@cityofzion/blockchain-service 1.6.0 → 1.8.0

package/dist/BSAggregator.d.ts

@@ -1,15 +1,14 @@
 import { Account, BlockchainService } from './interfaces';
-export declare class BSAggregator<BSCustomName extends string = string, BSCustom extends BlockchainService<BSCustomName, string> = BlockchainService<BSCustomName, string>> {
+export declare class BSAggregator<BSName extends string = string> {
     #private;
-    readonly blockchainServicesByName: Record<BSCustomName, BSCustom>;
-    constructor(blockchainServices: Record<BSCustomName, BSCustom>);
-    addBlockchain(name: BSCustomName, blockchain: BSCustom): void;
+    readonly blockchainServicesByName: Record<BSName, BlockchainService<BSName>>;
+    constructor(blockchainServices: BlockchainService<BSName>[]);
     validateAddressAllBlockchains(address: string): boolean;
     validateTextAllBlockchains(text: string): boolean;
     validateKeyAllBlockchains(wif: string): boolean;
     validateEncryptedAllBlockchains(keyOrJson: string): boolean;
-    getBlockchainNameByAddress(address: string): BSCustomName[];
-    getBlockchainNameByKey(wif: string): BSCustomName[];
-    getBlockchainNameByEncrypted(keyOrJson: string): BSCustomName[];
-    generateAccountsFromMnemonic(mnemonic: string): Promise<Map<BSCustomName, Account[]>>;
+    getBlockchainNameByAddress(address: string): BSName[];
+    getBlockchainNameByKey(wif: string): BSName[];
+    getBlockchainNameByEncrypted(keyOrJson: string): BSName[];
+    generateAccountsFromMnemonic(mnemonic: string): Promise<Map<BSName, Account<BSName>[]>>;
 }

package/dist/BSAggregator.js

@@ -26,14 +26,14 @@ const functions_1 = require("./functions");
 class BSAggregator {
     constructor(blockchainServices) {
         _BSAggregator_blockchainServices.set(this, void 0);
-        this.blockchainServicesByName = blockchainServices;
-        __classPrivateFieldSet(this, _BSAggregator_blockchainServices, Object.values(blockchainServices), "f");
-    }
-    addBlockchain(name, blockchain) {
-        if (this.blockchainServicesByName[name])
-            throw new Error(`The blockchain ${name} already exist`);
-        this.blockchainServicesByName[name] = blockchain;
-        __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").push(blockchain);
+        __classPrivateFieldSet(this, _BSAggregator_blockchainServices, blockchainServices, "f");
+        this.blockchainServicesByName = blockchainServices.reduce((acc, service) => {
+            if (acc[service.name]) {
+                throw new Error(`Duplicate blockchain service name: ${service.name}`);
+            }
+            acc[service.name] = service;
+            return acc;
+        }, {});
     }
     validateAddressAllBlockchains(address) {
         return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateAddress(address));
@@ -48,13 +48,13 @@ class BSAggregator {
         return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateEncrypted(keyOrJson));
     }
     getBlockchainNameByAddress(address) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateAddress(address)).map(bs => bs.blockchainName);
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateAddress(address)).map(bs => bs.name);
     }
     getBlockchainNameByKey(wif) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateKey(wif)).map(bs => bs.blockchainName);
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateKey(wif)).map(bs => bs.name);
     }
     getBlockchainNameByEncrypted(keyOrJson) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateEncrypted(keyOrJson)).map(bs => bs.blockchainName);
+        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateEncrypted(keyOrJson)).map(bs => bs.name);
     }
     generateAccountsFromMnemonic(mnemonic) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/CryptoCompareEDS.js

@@ -72,7 +72,7 @@ class CryptoCompareEDS {
     }
     getCurrencyRatio(currency) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield axios_1.default.get(`https://api.flamingo.finance/fiat/exchange-rate?pair=USD_${currency}`);
+            const { data } = yield axios_1.default.get(`https://neo-api.b-cdn.net/flamingo/live-data/fiat-exchange-rate/USD_${currency}`);
             return data;
         });
     }

package/dist/functions.d.ts

@@ -1,10 +1,9 @@
-import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, BSWithSwap } 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 hasSwap(service: BlockchainService): service is BlockchainService & BSWithSwap;
-export declare function waitForTransaction(service: BlockchainService, txId: string): Promise<boolean>;
-export declare function fetchAccountsForBlockchainServices<BSCustomName extends string = string>(blockchainServices: BlockchainService<BSCustomName>[], getAccountCallback: (service: BlockchainService<BSCustomName>, index: number) => Promise<Account>): Promise<Map<BSCustomName, Account[]>>;
+import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft } 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 waitForTransaction<BSName extends string = string>(service: BlockchainService<BSName>, txId: string): Promise<boolean>;
+export declare function fetchAccountsForBlockchainServices<BSName extends string = string>(blockchainServices: BlockchainService<BSName>[], getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Map<BSName, Account<BSName>[]>>;

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.fetchAccountsForBlockchainServices = exports.waitForTransaction = exports.hasSwap = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+exports.fetchAccountsForBlockchainServices = 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;
 }
@@ -34,10 +34,6 @@ function hasLedger(service) {
     return 'ledgerService' in service;
 }
 exports.hasLedger = hasLedger;
-function hasSwap(service) {
-    return 'createSwapService' in service;
-}
-exports.hasSwap = hasSwap;
 function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -85,7 +81,7 @@ function fetchAccountsForBlockchainServices(blockchainServices, getAccountCallba
                 accounts.push(generatedAccount);
                 index++;
             }
-            accountsByBlockchainService.set(service.blockchainName, accounts);
+            accountsByBlockchainService.set(service.name, accounts);
         }));
         yield Promise.all(promises);
         return accountsByBlockchainService;

package/dist/interfaces.d.ts

@@ -1,17 +1,19 @@
 import Transport from '@ledgerhq/hw-transport';
 import TypedEmitter from 'typed-emitter';
-export type Account = {
+export type Account<BSName extends string = string> = {
     key: string;
     type: 'wif' | 'privateKey' | 'publicKey';
     address: string;
     bip44Path?: string;
+    isHardware?: boolean;
+    blockchain: BSName;
 };
-export interface Token {
+export type Token = {
     symbol: string;
     name: string;
     hash: string;
     decimals: number;
-}
+};
 export type NetworkId<T extends string = string> = T | (string & {});
 export type Network<T extends string = string> = {
     id: NetworkId<T>;
@@ -24,15 +26,14 @@ export type IntentTransferParam = {
     amount: string;
     tokenDecimals?: number;
 };
-export type TransferParam = {
-    senderAccount: Account;
+export type TransferParam<BSName extends string = string> = {
+    senderAccount: Account<BSName>;
     intents: IntentTransferParam[];
     tipIntent?: IntentTransferParam;
     priorityFee?: string;
-    isLedger?: boolean;
 };
-export interface BlockchainService<BSCustomName extends string = string, BSAvailableNetworks extends string = string> {
-    readonly blockchainName: BSCustomName;
+export interface BlockchainService<BSName extends string = string, BSAvailableNetworks extends string = string> {
+    readonly name: BSName;
     readonly bip44DerivationPath: string;
     readonly feeToken: Token;
     exchangeDataService: ExchangeDataService;
@@ -41,23 +42,23 @@ export interface BlockchainService<BSCustomName extends string = string, BSAvail
     network: Network<BSAvailableNetworks>;
     testNetwork: (network: Network<BSAvailableNetworks>) => Promise<void>;
     setNetwork: (partialNetwork: Network<BSAvailableNetworks>) => void;
-    generateAccountFromMnemonic(mnemonic: string, index: number): Account;
-    generateAccountFromKey(key: string): Account;
-    decrypt(keyOrJson: string, password: string): Promise<Account>;
+    generateAccountFromMnemonic(mnemonic: string, index: number): Account<BSName>;
+    generateAccountFromKey(key: string): Account<BSName>;
+    decrypt(keyOrJson: string, password: string): Promise<Account<BSName>>;
     encrypt(key: string, password: string): Promise<string>;
     validateAddress(address: string): boolean;
     validateEncrypted(keyOrJson: string): boolean;
     validateKey(key: string): boolean;
-    transfer(param: TransferParam): Promise<string[]>;
+    transfer(param: TransferParam<BSName>): Promise<string[]>;
 }
-export interface BSCalculableFee {
-    calculateTransferFee(param: TransferParam, details?: boolean): Promise<string>;
+export interface BSCalculableFee<BSName extends string = string> {
+    calculateTransferFee(param: TransferParam<BSName>, details?: boolean): Promise<string>;
 }
-export interface BSClaimable {
+export interface BSClaimable<BSName extends string = string> {
     readonly claimToken: Token;
     readonly burnToken: Token;
     blockchainDataService: BlockchainDataService & BDSClaimable;
-    claim(account: Account, isLedger?: boolean): Promise<string>;
+    claim(account: Account<BSName>): Promise<string>;
 }
 export interface BSWithNameService {
     resolveNameServiceDomain(domainName: string): Promise<string>;
@@ -69,12 +70,9 @@ export interface BSWithExplorerService {
 export interface BSWithNft {
     nftDataService: NftDataService;
 }
-export interface BSWithLedger {
-    ledgerService: LedgerService;
-    generateAccountFromPublicKey(publicKey: string): Account;
-}
-export interface BSWithSwap<BSAvailableNetworks extends string = string> {
-    createSwapService(): SwapService<BSAvailableNetworks>;
+export interface BSWithLedger<BSName extends string = string> {
+    ledgerService: LedgerService<BSName>;
+    generateAccountFromPublicKey(publicKey: string): Account<BSName>;
 }
 export type TransactionNotifications = {
     eventName: string;
@@ -222,65 +220,61 @@ export type LedgerServiceEmitter = TypedEmitter<{
     getSignatureStart(): void | Promise<void>;
     getSignatureEnd(): void | Promise<void>;
 }>;
-export type GetLedgerTransport = (account: Account) => Promise<Transport>;
-export interface LedgerService {
+export type GetLedgerTransport<BSName extends string = string> = (account: Account<BSName>) => Promise<Transport>;
+export interface LedgerService<BSName extends string = string> {
     emitter: LedgerServiceEmitter;
-    getLedgerTransport?: GetLedgerTransport;
-    getAccounts(transport: Transport): Promise<Account[]>;
-    getAccount(transport: Transport, index: number): Promise<Account>;
+    getLedgerTransport?: GetLedgerTransport<BSName>;
+    getAccounts(transport: Transport): Promise<Account<BSName>[]>;
+    getAccount(transport: Transport, index: number): Promise<Account<BSName>>;
 }
-export type SwapRoute = {
-    tokenToUse: Token;
-    reserveTokenToUse: string;
-    tokenToReceive: Token;
-    reserveTokenToReceive: string;
+export type SwapServiceToken<BSName extends string = string> = {
+    id: string;
+    blockchain?: BSName;
+    imageUrl?: string;
+    symbol: string;
+    name: string;
+    hash?: string;
+    decimals?: number;
 };
-export type SwapServiceEvents = {
-    accountToUse: (account: Account | null) => void | Promise<void>;
-    amountToUse: (amount: string | null) => void | Promise<void>;
-    tokenToUse: (token: Token | null) => void | Promise<void>;
-    reservesToUse: (reserves: string | null) => void | Promise<void>;
-    amountToReceive: (amount: string | null) => void | Promise<void>;
-    tokenToReceive: (token: Token | null) => void | Promise<void>;
-    reservesToReceive: (reserves: string | null) => void | Promise<void>;
-    minimumReceived: (minimumReceived: string | null) => void | Promise<void>;
-    maximumSelling: (maximumSelling: string | null) => void | Promise<void>;
-    deadline: (deadline: string) => void | Promise<void>;
-    slippage: (slippage: number) => void | Promise<void>;
-    liquidityProviderFee: (liquidityProviderFee: string | null) => void | Promise<void>;
-    priceImpact: (priceImpact: string | null) => void | Promise<void>;
-    priceInverse: (priceInverse: string | null) => void | Promise<void>;
-    route: (route: SwapRoute[] | null) => void | Promise<void>;
-    lastAmountChanged: (lastAmountChanged: 'amountToUse' | 'amountToReceive' | null) => void | Promise<void>;
+export type SwapServiceLoadableValue<T> = {
+    loading: boolean;
+    value: T | null;
 };
-export type SwapServiceSwapArgs<T extends string> = {
-    address: string;
-    routePath: Token[];
-    deadline: string;
-    network: Network<T>;
+export type SwapServiceValidateValue<T> = SwapServiceLoadableValue<T> & {
+    valid: boolean | null;
+};
+export type SwapServiceMinMaxAmount = {
+    min: string;
+    max: string | null;
+};
+export type SwapServiceEvents<BSName extends string = string> = {
+    accountToUse: (account: SwapServiceValidateValue<Account<BSName>>) => void | Promise<void>;
+    amountToUse: (amount: SwapServiceLoadableValue<string>) => void | Promise<void>;
+    amountToUseMinMax: (minMax: SwapServiceLoadableValue<SwapServiceMinMaxAmount>) => void | Promise<void>;
+    tokenToUse: (token: SwapServiceLoadableValue<SwapServiceToken<BSName>>) => void | Promise<void>;
+    availableTokensToUse: (tokens: SwapServiceLoadableValue<SwapServiceToken<BSName>[]>) => void | Promise<void>;
+    addressToReceive: (account: SwapServiceValidateValue<string>) => void | Promise<void>;
+    amountToReceive: (amount: SwapServiceLoadableValue<string>) => void | Promise<void>;
+    tokenToReceive: (token: SwapServiceLoadableValue<SwapServiceToken<BSName>>) => void | Promise<void>;
+    availableTokensToReceive: (tokens: SwapServiceLoadableValue<SwapServiceToken<BSName>[]>) => void | Promise<void>;
+};
+export type SwapServiceSwapResult = {
+    transactionHash: string;
+    numberOfTransactions: number;
+    id: string;
+};
+export type SwapServiceStatusResponse = {
+    status: 'finished' | 'confirming' | 'exchanging' | 'failed';
+    transactionHashes: string[];
 };
-export type SwapServiceSwapToUseArgs<T extends string> = {
-    amountToUse: string;
-    minimumReceived: string;
-    type: 'swapTokenToUse';
-} & SwapServiceSwapArgs<T>;
-export type SwapServiceSwapToReceiveArgs<T extends string> = {
-    amountToReceive: string;
-    maximumSelling: string;
-    type: 'swapTokenToReceive';
-} & SwapServiceSwapArgs<T>;
-export type PoolGraph = Record<string, string[]>;
-export interface SwapService<AvailableNetworkIds extends string> {
-    eventEmitter: TypedEmitter<SwapServiceEvents>;
-    buildSwapInvocationArgs(): SwapServiceSwapToUseArgs<AvailableNetworkIds> | SwapServiceSwapToReceiveArgs<AvailableNetworkIds>;
-    setAccountToUse(account: Account | null): void;
-    setAmountToUse(amount: string | null): void;
-    setAmountToReceive(amount: string | null): void;
-    setDeadline(deadline: string): void;
-    setSlippage(slippage: number): void;
-    setTokenToUse(token: Token | null): void;
-    setTokenToReceive(token: Token | null): void;
-    startListeningBlockGeneration(): void;
-    stopListeningBlockGeneration(): void;
-    swap(isLedger?: boolean): void;
+export interface SwapService<BSName extends string = string> {
+    eventEmitter: TypedEmitter<SwapServiceEvents<BSName>>;
+    setTokenToUse(token: SwapServiceToken<BSName> | null): Promise<void>;
+    setAccountToUse(account: Account<BSName> | null): Promise<void>;
+    setAmountToUse(amount: string | null): Promise<void>;
+    setTokenToReceive(token: SwapServiceToken<BSName> | null): Promise<void>;
+    setAddressToReceive(address: string | null): Promise<void>;
+    swap(): Promise<SwapServiceSwapResult>;
+    calculateFee(): Promise<string>;
+    getStatus(): Promise<SwapServiceStatusResponse>;
 }

package/package.json

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