@cityofzion/blockchain-service 3.1.10 → 3.1.12

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

@@ -459,20 +459,27 @@ 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.10",
+  "version": "3.1.12",
   "repository": "https://github.com/CityOfZion/blockchain-services",
   "license": "GPL-3.0-only",
   "author": "Coz",