@cityofzion/blockchain-service 1.19.1 → 1.19.2

package/dist/error.d.ts

@@ -1,4 +1,6 @@
 export declare class BSError extends Error {
     readonly code: string;
-    constructor(message: string, code: string);
+    readonly sourceError?: Error;
+    constructor(message: string, code: string, sourceError?: any);
+    toString(): string;
 }

package/dist/error.js

@@ -2,10 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSError = void 0;
 class BSError extends Error {
-    constructor(message, code) {
+    constructor(message, code, sourceError) {
         super(message);
         this.code = code;
         this.name = 'BSError';
+        this.sourceError = sourceError;
+        // Set the prototype explicitly to maintain the correct prototype chain
+        Object.setPrototypeOf(this, BSError.prototype);
+    }
+    toString() {
+        return (`[${this.name} - ${this.code}]: ${this.message}` + (this.sourceError ? ` | Caused by: ${this.sourceError}` : ''));
     }
 }
 exports.BSError = BSError;

package/dist/helpers/BSAccountHelper.d.ts

@@ -0,0 +1,8 @@
+export type TBSAccountHelperPredicateParams = {
+    address: string;
+    blockchain: string;
+};
+export declare class BSAccountHelper {
+    static predicate({ address, blockchain }: TBSAccountHelperPredicateParams): (account: TBSAccountHelperPredicateParams) => boolean;
+    static predicateNot({ address, blockchain }: TBSAccountHelperPredicateParams): (account: TBSAccountHelperPredicateParams) => boolean;
+}

package/dist/helpers/BSAccountHelper.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSAccountHelper = void 0;
+class BSAccountHelper {
+    static predicate({ address, blockchain }) {
+        return (account) => address === account.address && blockchain === account.blockchain;
+    }
+    static predicateNot({ address, blockchain }) {
+        return (account) => address !== account.address || blockchain !== account.blockchain;
+    }
+}
+exports.BSAccountHelper = BSAccountHelper;

package/dist/helpers/BSTokenHelper.d.ts

@@ -1,10 +1,10 @@
 import { Token } from '../interfaces';
-type TPredicateToken = {
+export type TBSTokenHelperPredicateParams = {
     hash: string;
     symbol?: string;
 };
 export declare class BSTokenHelper {
-    static predicate({ hash, symbol }: TPredicateToken): (params: TPredicateToken) => boolean;
+    static predicate({ hash, symbol }: TBSTokenHelperPredicateParams): (params: TBSTokenHelperPredicateParams) => boolean;
     static predicateByHash(tokenOrHash: string | {
         hash: string;
     }): (params: string | {
@@ -18,4 +18,3 @@ export declare class BSTokenHelper {
     static normalizeToken<T extends Token | Token[]>(token: T): T;
     static normalizeHash(hash: string): string;
 }
-export {};

package/dist/index.d.ts

@@ -4,9 +4,9 @@ export * from './helpers/BSPromisesHelper';
 export * from './helpers/BSBigNumberHelper';
 export * from './helpers/BSTokenHelper';
 export * from './helpers/BSUtilsHelper';
+export * from './helpers/BSAccountHelper';
 export * from './services/exchange-data/CryptoCompareEDS';
 export * from './services/exchange-data/FlamingoForthewinEDS';
-export * from './BSAggregator';
 export * from './functions';
 export * from './interfaces';
 export * from './error';

package/dist/index.js

@@ -20,9 +20,9 @@ __exportStar(require("./helpers/BSPromisesHelper"), exports);
 __exportStar(require("./helpers/BSBigNumberHelper"), exports);
 __exportStar(require("./helpers/BSTokenHelper"), exports);
 __exportStar(require("./helpers/BSUtilsHelper"), exports);
+__exportStar(require("./helpers/BSAccountHelper"), exports);
 __exportStar(require("./services/exchange-data/CryptoCompareEDS"), exports);
 __exportStar(require("./services/exchange-data/FlamingoForthewinEDS"), exports);
-__exportStar(require("./BSAggregator"), exports);
 __exportStar(require("./functions"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./error"), exports);

package/dist/interfaces.d.ts

@@ -1,5 +1,6 @@
 import Transport from '@ledgerhq/hw-transport';
 import TypedEmitter from 'typed-emitter';
+import { BSError } from './error';
 export type UntilIndexRecord<BSName extends string = string> = Partial<Record<BSName, Record<string, number>>>;
 export type Account<BSName extends string = string> = {
     key: string;
@@ -76,9 +77,6 @@ export interface BSWithLedger<BSName extends string = string> {
     ledgerService: LedgerService<BSName>;
     generateAccountFromPublicKey(publicKey: string): Account<BSName>;
 }
-export interface IBSWithNeo3NeoXBridge<BSName extends string = string> {
-    neo3NeoXBridgeService: INeo3NeoXBridgeService<BSName>;
-}
 export type TransactionNotificationTypedResponse = {
     type: string;
     value?: string;
@@ -300,7 +298,7 @@ export interface LedgerService<BSName extends string = string> {
     getAccounts(transport: Transport, getUntilIndex?: UntilIndexRecord<BSName>): Promise<Account<BSName>[]>;
     getAccount(transport: Transport, index: number): Promise<Account<BSName>>;
 }
-export type SwapServiceToken<BSName extends string = string> = {
+export type TSwapToken<BSName extends string = string> = {
     id: string;
     blockchain?: BSName;
     imageUrl?: string;
@@ -313,86 +311,123 @@ export type SwapServiceToken<BSName extends string = string> = {
     network?: string;
     hasExtraId: boolean;
 };
-export type SwapServiceLoadableValue<T> = {
+export type TSwapLoadableValue<T> = {
     loading: boolean;
     value: T | null;
 };
-export type SwapServiceValidateValue<T> = SwapServiceLoadableValue<T> & {
+export type TSwapValidateValue<T> = TSwapLoadableValue<T> & {
     valid: boolean | null;
 };
-export type SwapServiceMinMaxAmount = {
+export type TSwapMinMaxAmount = {
     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>;
-    extraIdToReceive: (extraIdToReceive: SwapServiceValidateValue<string>) => 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 TSwapOrchestratorEvents<BSName extends string = string> = {
+    accountToUse: (account: TSwapValidateValue<Account<BSName>>) => void | Promise<void>;
+    amountToUse: (amount: TSwapLoadableValue<string>) => void | Promise<void>;
+    amountToUseMinMax: (minMax: TSwapLoadableValue<TSwapMinMaxAmount>) => void | Promise<void>;
+    tokenToUse: (token: TSwapLoadableValue<TSwapToken<BSName>>) => void | Promise<void>;
+    availableTokensToUse: (tokens: TSwapLoadableValue<TSwapToken<BSName>[]>) => void | Promise<void>;
+    addressToReceive: (account: TSwapValidateValue<string>) => void | Promise<void>;
+    extraIdToReceive: (extraIdToReceive: TSwapValidateValue<string>) => void;
+    amountToReceive: (amount: TSwapLoadableValue<string>) => void | Promise<void>;
+    tokenToReceive: (token: TSwapLoadableValue<TSwapToken<BSName>>) => void | Promise<void>;
+    availableTokensToReceive: (tokens: TSwapLoadableValue<TSwapToken<BSName>[]>) => void | Promise<void>;
     error: (error: string) => void | Promise<void>;
 };
-export type SwapServiceSwapResult = {
+export type TSwapResult = {
     id: string;
     txFrom?: string;
     log?: string;
 };
-export type SwapServiceStatusResponse = {
+export type TSwapServiceStatusResponse = {
     status: 'finished' | 'confirming' | 'exchanging' | 'failed' | 'refunded';
     txFrom?: string;
     txTo?: string;
     log?: string;
 };
-export interface SwapServiceHelper {
-    getStatus(id: string): Promise<SwapServiceStatusResponse>;
+export interface ISwapService {
+    getStatus(id: string): Promise<TSwapServiceStatusResponse>;
 }
-export interface SwapService<BSName extends string = string> {
-    eventEmitter: TypedEmitter<SwapServiceEvents<BSName>>;
-    setTokenToUse(token: SwapServiceToken<BSName> | null): Promise<void>;
+export interface ISwapOrchestrator<BSName extends string = string> {
+    eventEmitter: TypedEmitter<TSwapOrchestratorEvents<BSName>>;
+    setTokenToUse(token: TSwapToken<BSName> | null): Promise<void>;
     setAccountToUse(account: Account<BSName> | null): Promise<void>;
     setAmountToUse(amount: string | null): Promise<void>;
-    setTokenToReceive(token: SwapServiceToken<BSName> | null): Promise<void>;
+    setTokenToReceive(token: TSwapToken<BSName> | null): Promise<void>;
     setAddressToReceive(address: string | null): Promise<void>;
     setExtraIdToReceive(extraId: string | null): Promise<void>;
-    swap(): Promise<SwapServiceSwapResult>;
+    swap(): Promise<TSwapResult>;
     calculateFee(): Promise<string>;
 }
-export type TNeo3NeoXBridgeServiceCalculateMaxAmountParams<BSName extends string> = {
-    account: Account<BSName>;
-    receiverAddress: string;
-    token: Token;
-    balances: BalanceResponse[];
+export type TBridgeToken = Token & {
+    multichainId: string;
 };
-export type TNeo3NeoXBridgeServiceValidatedInputs = {
-    amount: string;
-    receiveAmount: string;
-    token: Token;
+export type TBridgeValue<T> = {
+    value: T | null;
+    loading: boolean;
+    error: BSError | null;
+};
+export type TBridgeValidateValue<T> = TBridgeValue<T> & {
+    valid: boolean | null;
 };
-export type TNeo3NeoXBridgeServiceBridgeParam<BSName extends string> = {
+export type TBridgeOrchestratorEvents<BSName extends string = string> = {
+    accountToUse: (account: TBridgeValue<Account<BSName>>) => void | Promise<void>;
+    amountToUse: (amount: TBridgeValidateValue<string>) => void | Promise<void>;
+    amountToUseMin: (max: TBridgeValue<string>) => void | Promise<void>;
+    amountToUseMax: (max: TBridgeValue<string>) => void | Promise<void>;
+    tokenToUse: (token: TBridgeValue<TBridgeToken>) => void | Promise<void>;
+    availableTokensToUse: (tokens: TBridgeValue<TBridgeToken[]>) => void | Promise<void>;
+    addressToReceive: (account: TBridgeValidateValue<string>) => void | Promise<void>;
+    amountToReceive: (amount: TBridgeValue<string>) => void | Promise<void>;
+    tokenToReceive: (token: TBridgeValue<TBridgeToken>) => void | Promise<void>;
+    tokenToUseBalance: (balance: TBridgeValue<BalanceResponse | undefined>) => void | Promise<void>;
+    bridgeFee: (fee: TBridgeValue<string>) => void | Promise<void>;
+};
+export interface IBridgeOrchestrator<BSName extends string = string> {
+    eventEmitter: TypedEmitter<TBridgeOrchestratorEvents<BSName>>;
+    setTokenToUse(token: TBridgeToken | null): Promise<void>;
+    setAccountToUse(account: Account<BSName> | null): Promise<void>;
+    setAmountToUse(amount: string | null): Promise<void>;
+    setAddressToReceive(address: string | null): Promise<void>;
+    setBalances(balances: BalanceResponse[] | null): Promise<void>;
+    switchTokens(): Promise<void>;
+    bridge(): Promise<string>;
+    wait(): Promise<boolean>;
+}
+export interface IBSWithNeo3NeoXBridge<BSName extends string = string> {
+    neo3NeoXBridgeService: INeo3NeoXBridgeService<BSName>;
+}
+export type TNeo3NeoXBridgeServiceConstants = {
+    bridgeFee: string;
+    bridgeMaxAmount: string;
+    bridgeMinAmount: string;
+};
+export type TNeo3NeoXBridgeServiceBridgeParam<BSName extends string = string> = {
     account: Account<BSName>;
     receiverAddress: string;
-    validatedInputs: TNeo3NeoXBridgeServiceValidatedInputs;
+    amount: string;
+    token: TBridgeToken;
+    bridgeFee: string;
 };
-export type TNeo3NeoXBridgeServiceValidateInputParams<BSName extends string> = {
+export type TNeo3NeoXBridgeServiceGetApprovalParam<BSName extends string = string> = {
     account: Account<BSName>;
-    receiverAddress: string;
     amount: string;
-    token: Token;
-    balances: BalanceResponse[];
+    token: TBridgeToken;
 };
-export type TNeo3NeoXBridgeServiceWaitParams = {
+export type TNeo3NeoXBridgeServiceGetNonceParams = {
+    token: TBridgeToken;
     transactionHash: string;
-    validatedInputs: TNeo3NeoXBridgeServiceValidatedInputs;
+};
+export type TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams = {
+    token: TBridgeToken;
+    nonce: string;
 };
 export interface INeo3NeoXBridgeService<BSName extends string = string> {
-    calculateMaxAmount(params: TNeo3NeoXBridgeServiceCalculateMaxAmountParams<BSName>): Promise<string>;
-    calculateFee(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    tokens: TBridgeToken[];
+    getApprovalFee(params: TNeo3NeoXBridgeServiceGetApprovalParam): Promise<string>;
+    getBridgeConstants(token: TBridgeToken): Promise<TNeo3NeoXBridgeServiceConstants>;
     bridge(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
-    validateInputs(params: TNeo3NeoXBridgeServiceValidateInputParams<BSName>): Promise<TNeo3NeoXBridgeServiceValidatedInputs>;
-    wait(params: TNeo3NeoXBridgeServiceWaitParams): Promise<boolean>;
+    getNonce(params: TNeo3NeoXBridgeServiceGetNonceParams): Promise<string | null>;
+    getTransactionHashByNonce(params: TNeo3NeoXBridgeServiceGetTransactionHashByNonceParams): Promise<string | null>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/blockchain-service",
-  "version": "1.19.1",
+  "version": "1.19.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -23,7 +23,7 @@
     "ts-jest": "29.1.1"
   },
   "dependencies": {
-    "@ledgerhq/hw-transport": "~6.30.5",
+    "@ledgerhq/hw-transport": "~6.31.8",
     "axios": "1.8.2",
     "date-fns": "~4.1.0",
     "bignumber.js": "~9.3.0"

package/dist/BSAggregator.d.ts

@@ -1,14 +0,0 @@
-import { Account, BlockchainService, UntilIndexRecord } from './interfaces';
-export declare class BSAggregator<BSName extends string = string> {
-    #private;
-    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): BSName[];
-    getBlockchainNameByKey(wif: string): BSName[];
-    getBlockchainNameByEncrypted(keyOrJson: string): BSName[];
-    generateAccountsFromMnemonic(mnemonic: string, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Map<BSName, Account<BSName>[]>>;
-}

package/dist/BSAggregator.js

@@ -1,68 +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 __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 functions_1 = require("./functions");
-class BSAggregator {
-    constructor(blockchainServices) {
-        _BSAggregator_blockchainServices.set(this, void 0);
-        __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));
-    }
-    validateTextAllBlockchains(text) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => [bs.validateAddress(text), bs.validateEncrypted(text), bs.validateKey(text)].some(it => it === true));
-    }
-    validateKeyAllBlockchains(wif) {
-        return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").some(bs => bs.validateKey(wif));
-    }
-    validateEncryptedAllBlockchains(keyOrJson) {
-        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.name);
-    }
-    getBlockchainNameByKey(wif) {
-        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.name);
-    }
-    generateAccountsFromMnemonic(mnemonic, untilIndexByBlockchainService) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, functions_1.generateAccountForBlockchainService)(__classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f"), (service, index) => __awaiter(this, void 0, void 0, function* () {
-                return service.generateAccountFromMnemonic(mnemonic, index);
-            }), untilIndexByBlockchainService);
-        });
-    }
-}
-exports.BSAggregator = BSAggregator;
-_BSAggregator_blockchainServices = new WeakMap();