@cityofzion/blockchain-service 3.1.9 → 3.1.11

package/dist/helpers/BSBigNumberHelper.d.ts

@@ -1,12 +1,25 @@
 import BigNumber from 'bignumber.js';
-import { TBSBigNumberHelperFormatOptions } from '../types';
-export type TBSBigNumber = BigNumber;
-export declare const BSBigNumber: typeof BigNumber;
-export declare class BSBigNumberHelper {
-    #private;
-    static toDecimals(value: TBSBigNumber, decimals: number | string): string;
-    static toNumber(value: TBSBigNumber, decimals?: number | string): string;
-    static fromNumber(value: string | number | bigint | undefined): TBSBigNumber;
-    static fromDecimals(value: string | number | bigint | TBSBigNumber | undefined, decimals: number | string): TBSBigNumber;
-    static format(value: string | number | bigint | TBSBigNumber | undefined, options?: TBSBigNumberHelperFormatOptions): string;
+export declare class BSBigNumber extends BigNumber {
+    constructor(value: BigNumber.Value, base?: number);
+    static ensureNumber(value: number | string | bigint | undefined): number;
+    toBigInt(): bigint;
+    protected _wrap(value: BigNumber): this;
+    plus(n: BigNumber.Value, base?: number): this;
+    minus(n: BigNumber.Value, base?: number): this;
+    multipliedBy(n: BigNumber.Value, base?: number): this;
+    dividedBy(n: BigNumber.Value, base?: number): this;
+    integerValue(roundingMode?: BigNumber.RoundingMode): this;
+}
+export declare class BSBigHumanAmount extends BSBigNumber {
+    decimals?: number;
+    constructor(value: BigNumber.Value | undefined | null, decimals?: number | string);
+    protected _wrap(value: BigNumber): this;
+    toFormatted(): string;
+    toUnit(): BSBigUnitAmount;
+}
+export declare class BSBigUnitAmount extends BSBigNumber {
+    decimals?: number;
+    constructor(value: BigNumber.Value | undefined | null, decimals: number | string);
+    protected _wrap(value: BigNumber): this;
+    toHuman(): BSBigHumanAmount;
 }

package/dist/helpers/BSBigNumberHelper.js

@@ -1,62 +1,87 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _b, _BSBigNumberHelper_ensureDecimals;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BSBigNumberHelper = exports.BSBigNumber = void 0;
+exports.BSBigUnitAmount = exports.BSBigHumanAmount = exports.BSBigNumber = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
-exports.BSBigNumber = bignumber_js_1.default;
-class BSBigNumberHelper {
-    static toDecimals(value, decimals) {
-        const decimalsNumber = __classPrivateFieldGet(this, _b, "m", _BSBigNumberHelper_ensureDecimals).call(this, decimals);
-        return new exports.BSBigNumber(value).shiftedBy(decimalsNumber).toString();
-    }
-    static toNumber(value, decimals) {
-        const decimalsNumber = __classPrivateFieldGet(this, _b, "m", _BSBigNumberHelper_ensureDecimals).call(this, decimals);
-        return typeof decimals === 'number' || typeof decimals === 'string'
-            ? value.toFixed(decimalsNumber)
-            : value.toFixed();
-    }
-    static fromNumber(value) {
-        return new exports.BSBigNumber(value || 0);
-    }
-    static fromDecimals(value, decimals) {
-        const decimalsNumber = __classPrivateFieldGet(this, _b, "m", _BSBigNumberHelper_ensureDecimals).call(this, decimals);
-        return new exports.BSBigNumber(value || 0).shiftedBy(-decimalsNumber);
-    }
-    static format(value, options) {
-        if (!value)
-            return '0';
+const error_1 = require("../error");
+class BSBigNumber extends bignumber_js_1.default {
+    constructor(value, base) {
+        super(value, base);
+    }
+    static ensureNumber(value) {
+        const bn = new bignumber_js_1.default(value || 0);
+        if (bn.isNaN()) {
+            return 0;
+        }
+        return bn.toNumber();
+    }
+    toBigInt() {
+        return BigInt(this.toString());
+    }
+    _wrap(value) {
+        return new this.constructor(value);
+    }
+    plus(n, base) {
+        return this._wrap(super.plus(n, base));
+    }
+    minus(n, base) {
+        return this._wrap(super.minus(n, base));
+    }
+    multipliedBy(n, base) {
+        return this._wrap(super.multipliedBy(n, base));
+    }
+    dividedBy(n, base) {
+        return this._wrap(super.dividedBy(n, base));
+    }
+    integerValue(roundingMode) {
+        return this._wrap(super.integerValue(roundingMode));
+    }
+}
+exports.BSBigNumber = BSBigNumber;
+class BSBigHumanAmount extends BSBigNumber {
+    constructor(value, decimals) {
         if (typeof value === 'string') {
             value = value.replace(/,|\.\.|\.,/g, '.').replace(/^([^.]*\.)(.*)$/, function (_a, b, c) {
                 return b + c.replace(/\./g, '');
             });
         }
-        try {
-            const bigValue = new exports.BSBigNumber(value);
-            if (bigValue.isNaN()) {
-                return '0';
-            }
-            const decimals = __classPrivateFieldGet(this, _b, "m", _BSBigNumberHelper_ensureDecimals).call(this, options?.decimals);
-            const formattedValue = bigValue.decimalPlaces(decimals, exports.BSBigNumber.ROUND_DOWN);
-            return formattedValue.toFixed();
+        if (!value || new bignumber_js_1.default(value).isNaN()) {
+            value = 0;
         }
-        catch (error) {
-            console.error(error);
-            return '0';
+        super(value);
+        this.decimals = decimals !== undefined ? BSBigNumber.ensureNumber(decimals) : undefined;
+    }
+    _wrap(value) {
+        return new this.constructor(value, this.decimals);
+    }
+    toFormatted() {
+        return this.decimalPlaces(this.decimals ?? 0, bignumber_js_1.default.ROUND_DOWN).toFixed();
+    }
+    toUnit() {
+        if (typeof this.decimals !== 'number') {
+            throw new error_1.BSError('Decimals property is required to convert to Unit', 'DECIMALS_REQUIRED');
         }
+        const shifted = this.shiftedBy(this.decimals);
+        return new BSBigUnitAmount(shifted, this.decimals);
     }
 }
-exports.BSBigNumberHelper = BSBigNumberHelper;
-_b = BSBigNumberHelper, _BSBigNumberHelper_ensureDecimals = function _BSBigNumberHelper_ensureDecimals(value) {
-    if (!value)
-        return 0;
-    value = +value || 0;
-    return 0 > value ? 0 : value;
-};
+exports.BSBigHumanAmount = BSBigHumanAmount;
+class BSBigUnitAmount extends BSBigNumber {
+    constructor(value, decimals) {
+        if (!value || new bignumber_js_1.default(value).isNaN()) {
+            value = 0;
+        }
+        super(value);
+        this.decimals = BSBigNumber.ensureNumber(decimals);
+    }
+    _wrap(value) {
+        return new this.constructor(value, this.decimals);
+    }
+    toHuman() {
+        const shifted = this.shiftedBy(-this.decimals);
+        return new BSBigHumanAmount(shifted, this.decimals);
+    }
+}
+exports.BSBigUnitAmount = BSBigUnitAmount;

package/dist/interfaces.d.ts

@@ -24,15 +24,6 @@ export type TBSNetwork<T extends string = string> = {
     url: string;
     type: TBSNetworkType;
 };
-export type TTransferIntent = {
-    receiverAddress: string;
-    amount: string;
-    token: TBSToken;
-};
-export type TTransferParams<N extends string> = {
-    senderAccount: TBSAccount<N>;
-    intents: TTransferIntent[];
-};
 export type TPingNetworkResponse = {
     latency: number;
     url: string;
@@ -62,48 +53,30 @@ export interface IBlockchainService<N extends string, A extends string = string>
     validateKey(key: string): boolean;
     transfer(params: TTransferParams<N>): Promise<TTransaction<N>[]>;
 }
+export type TTransferIntent = {
+    receiverAddress: string;
+    amount: string;
+    token: TBSToken;
+};
+export type TTransferParams<N extends string> = {
+    senderAccount: TBSAccount<N>;
+    intents: TTransferIntent[];
+};
+export interface IBSWithFee<N extends string> {
+    calculateTransferFee(params: TTransferParams<N>): Promise<string>;
+}
 export interface IBSWithEncryption<N extends string> {
     decrypt(keyOrJson: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
     validateEncrypted(keyOrJson: string): boolean;
 }
-export interface IBSWithFee<N extends string> {
-    calculateTransferFee(params: TTransferParams<N>): Promise<string>;
-}
-export interface IBSWithClaim<N extends string> {
-    claimService: IClaimService<N>;
-}
 export interface IBSWithNameService {
     resolveNameServiceDomain(domainName: string): Promise<string>;
     validateNameServiceDomainFormat(domainName: string): boolean;
 }
-export interface IBSWithExplorer {
-    explorerService: IExplorerService;
-}
-export interface IBSWithNft {
-    nftDataService: INftDataService;
-}
-export interface IBSWithLedger<N extends string> {
-    ledgerService: ILedgerService<N>;
-    generateAccountFromPublicKey(publicKey: string): Promise<TBSAccount<N>>;
-}
-export interface IBSWithWalletConnect<N extends string> {
-    walletConnectService: IWalletConnectService<N>;
-}
-export interface IBSWithFullTransactions<N extends string> {
-    fullTransactionsDataService: IFullTransactionsDataService<N>;
-}
 export interface IBSWithFaucet<N extends string> {
     faucet(address: string): Promise<TTransaction<N>>;
 }
-export type TContractParameter = {
-    name: string;
-    type: string;
-};
-export type TGetTransactionsByAddressParams = {
-    address: string;
-    nextPageParams?: any;
-};
 export type TTransactionBaseEvent = {
     methodName?: string;
     from?: string;
@@ -125,6 +98,7 @@ export type TTransactionDefaultGenericEvent = TTransactionBaseEvent & {
     eventType: 'generic';
     data?: Record<string, string | number | boolean | undefined | null>;
 };
+export type TTransactionDefaultEvent = TTransactionDefaultNftEvent | TTransactionDefaultTokenEvent | TTransactionDefaultGenericEvent;
 export type TTransactionUtxoInputOutput = {
     address?: string;
     addressUrl?: string;
@@ -147,7 +121,6 @@ export type TTransactionFullBase<N extends string> = TTransactionBase & {
     blockchain: N;
     relatedAddress?: string;
 };
-export type TTransactionDefaultEvent = TTransactionDefaultNftEvent | TTransactionDefaultTokenEvent | TTransactionDefaultGenericEvent;
 export type TTransactionDefault<N extends string> = TTransactionFullBase<N> & {
     view: 'default';
     events: TTransactionDefaultEvent[];
@@ -161,10 +134,18 @@ export type TTransactionUtxo<N extends string> = TTransactionFullBase<N> & {
     outputs: TTransactionUtxoInputOutput[];
 };
 export type TTransaction<N extends string> = TTransactionDefault<N> | TTransactionUtxo<N>;
+export type TGetTransactionsByAddressParams = {
+    address: string;
+    nextPageParams?: any;
+};
 export type TGetTransactionsByAddressResponse<N extends string, T extends TTransaction<N> = TTransaction<N>> = {
     nextPageParams?: any;
     transactions: T[];
 };
+export type TContractParameter = {
+    name: string;
+    type: string;
+};
 export type TContractMethod = {
     name: string;
     parameters: TContractParameter[];
@@ -203,6 +184,9 @@ export interface IFullTransactionsDataService<N extends string> {
     getFullTransactionsByAddress(params: TGetFullTransactionsByAddressParams): Promise<TGetTransactionsByAddressResponse<N>>;
     exportFullTransactionsByAddress(params: TExportFullTransactionsByAddressParams): Promise<string>;
 }
+export interface IBSWithFullTransactions<N extends string> {
+    fullTransactionsDataService: IFullTransactionsDataService<N>;
+}
 export type TClaimServiceTransactionData = {
     isClaim: boolean;
 };
@@ -213,6 +197,9 @@ export interface IClaimService<N extends string> {
     claim(account: TBSAccount<N>): Promise<TTransactionDefault<N>>;
     getTransactionData(transaction: TTransactionBase): TClaimServiceTransactionData | undefined;
 }
+export interface IBSWithClaim<N extends string> {
+    claimService: IClaimService<N>;
+}
 export type TTokenPricesResponse = {
     usdPrice: number;
     token: TBSToken;
@@ -274,6 +261,9 @@ export interface INftDataService {
     getNft(params: TGetNftParams): Promise<TNftResponse>;
     hasToken(params: THasTokenParams): Promise<boolean>;
 }
+export interface IBSWithNft {
+    nftDataService: INftDataService;
+}
 export type TBuildNftUrlParams = {
     collectionHash?: string;
     tokenHash: string;
@@ -288,6 +278,9 @@ export interface IExplorerService {
     getNftTemplateUrl(): string | undefined;
     getContractTemplateUrl(): string | undefined;
 }
+export interface IBSWithExplorer {
+    explorerService: IExplorerService;
+}
 export type TLedgerServiceEmitter = TypedEmitter<{
     getSignatureStart(): void | Promise<void>;
     getSignatureEnd(): void | Promise<void>;
@@ -299,6 +292,10 @@ export interface ILedgerService<N extends string> {
     getAccount(transport: Transport, index: number): Promise<TBSAccount<N>>;
     getAccounts(transport: Transport, getUntilIndex?: TUntilIndexRecord<N>): Promise<TBSAccount<N>[]>;
 }
+export interface IBSWithLedger<N extends string> {
+    ledgerService: ILedgerService<N>;
+    generateAccountFromPublicKey(publicKey: string): Promise<TBSAccount<N>>;
+}
 export type TSwapToken<N extends string> = {
     id: string;
     blockchain?: N;
@@ -397,9 +394,6 @@ export interface IBridgeOrchestrator<N extends TBSBridgeName> {
     switchTokens(): Promise<void>;
     bridge(): Promise<string>;
 }
-export interface IBSWithNeo3NeoXBridge<N extends TBSBridgeName> {
-    neo3NeoXBridgeService: INeo3NeoXBridgeService<N>;
-}
 export type TNeo3NeoXBridgeServiceConstants = {
     bridgeFee: string;
     bridgeMaxAmount: string;
@@ -443,6 +437,9 @@ export interface INeo3NeoXBridgeService<N extends TBSBridgeName> {
     getTokenByMultichainId(multichainId: string): TBridgeToken<N> | undefined;
     getTransactionData(transaction: TTransactionBase): TNeo3NeoXBridgeTransactionData<N> | undefined;
 }
+export interface IBSWithNeo3NeoXBridge<N extends TBSBridgeName> {
+    neo3NeoXBridgeService: INeo3NeoXBridgeService<N>;
+}
 export type TTokenServicePredicateParams = {
     hash: string;
     symbol?: string;
@@ -462,18 +459,28 @@ export interface ITokenService {
     validateTokenHash(hash?: string): hash is string;
     isNativeToken(hash: string): boolean;
 }
-export type TWalletConnectServiceRequestMethodParams<N extends string> = {
+export type TWalletConnectServiceRequestMethodParams<N extends string, P = any> = {
     account: TBSAccount<N>;
-    params: any;
+    params: P;
+    method: string;
 };
-export type TWalletConnectServiceRequestMethod<N extends string> = (params: TWalletConnectServiceRequestMethodParams<N>) => Promise<any>;
-export interface IWalletConnectService<N extends string> {
+export type TWalletConnectServiceMethodHandler<N extends string, P = any> = {
+    validate: (params: any) => Promise<P>;
+    process: (args: TWalletConnectServiceRequestMethodParams<N, P>) => Promise<any>;
+};
+export type TWalletConnectServiceHandlers<N extends string, P extends Record<string, any> = Record<string, any>> = {
+    [K in keyof P]: TWalletConnectServiceMethodHandler<N, P[K]>;
+};
+export interface IWalletConnectService<N extends string, M extends string = string> {
     readonly namespace: string;
     readonly chain: string;
-    readonly supportedMethods: string[];
+    readonly supportedMethods: M[];
     readonly supportedEvents: string[];
-    readonly calculableMethods: string[];
-    readonly autoApproveMethods: string[];
+    readonly calculableMethods: M[];
+    readonly autoApproveMethods: M[];
+    handlers: TWalletConnectServiceHandlers<N>;
     calculateRequestFee(args: TWalletConnectServiceRequestMethodParams<N>): Promise<string>;
-    [methodName: string]: any | TWalletConnectServiceRequestMethod<N>;
+}
+export interface IBSWithWalletConnect<N extends string> {
+    walletConnectService: IWalletConnectService<N>;
 }

package/dist/types.d.ts

@@ -56,9 +56,6 @@ export type TCryptoCompareEDSHistoryResponse = {
     }[];
 };
 export type THexString = `0x${string}`;
-export type TBSBigNumberHelperFormatOptions = {
-    decimals?: number | string;
-};
 export type TBSUtilsHelperRetryOptions = {
     retries?: number;
     delay?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/blockchain-service",
-  "version": "3.1.9",
+  "version": "3.1.11",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",
@@ -10,7 +10,7 @@
     "/dist"
   ],
   "dependencies": {
-    "axios": "~1.13.5",
+    "axios": "~1.15.0",
     "bignumber.js": "~9.3.1",
     "bip39": "~3.1.0",
     "date-fns": "~4.1.0",