hive-keychain-commons 1.4.3 → 1.5.0

package/lib/index.d.ts

@@ -5,6 +5,9 @@ export { AcceptRequestJSON, CancelDelegationJSON, CancelRequestJSON, PaymentJSON
 export * from './swaps/config.interface';
 export * from './swaps/swap-api.interface';
 export * from './swaps/swap.interface';
+export * from './utils/assets.utils';
+export * from './utils/crypto.utils';
+export * from './utils/history-filters.utils';
 export * from './utils/keys.utils';
 export * from './utils/transfer.utils';
 export * from './utils/vsc.utils';

package/lib/index.js

@@ -22,6 +22,9 @@ Object.defineProperty(exports, "LeaseKeys", { enumerable: true, get: function ()
 __exportStar(require("./swaps/config.interface"), exports);
 __exportStar(require("./swaps/swap-api.interface"), exports);
 __exportStar(require("./swaps/swap.interface"), exports);
+__exportStar(require("./utils/assets.utils"), exports);
+__exportStar(require("./utils/crypto.utils"), exports);
+__exportStar(require("./utils/history-filters.utils"), exports);
 __exportStar(require("./utils/keys.utils"), exports);
 __exportStar(require("./utils/transfer.utils"), exports);
 __exportStar(require("./utils/vsc.utils"), exports);

package/lib/interfaces/keychain.d.ts

@@ -1,4 +1,4 @@
-import { Operation, Transaction } from '@hiveio/dhive';
+import type { Operation, Transaction } from '@hiveio/dhive';
 import { IStep } from '../swaps/swap.interface';
 export declare enum KeychainRequestTypes {
     decode = "decode",

package/lib/utils/assets.utils.d.ts

@@ -0,0 +1,78 @@
+import type { AssetSymbol, PriceType } from '@hiveio/dhive';
+export declare class Asset {
+    amount: number;
+    symbol: AssetSymbol;
+    constructor(amount: number, symbol: AssetSymbol);
+    /**
+     * Create a new Asset instance from a string, e.g. `42.000 HIVE`.
+     */
+    static fromString: (str: string, expectedSymbol?: AssetSymbol) => Asset;
+    /**
+     * Convenience to create new Asset.
+     * @param symbol Symbol to use when created from number. Will also be used to validate
+     *               the asset, throws if the passed value has a different symbol than this.
+     */
+    static from: (value: number | Asset | string, symbol?: AssetSymbol) => Asset;
+    /**
+     * Return the smaller of the two assets.
+     */
+    static min: (a: Asset, b: Asset) => Asset;
+    /**
+     * Return the larger of the two assets.
+     */
+    static max: (a: Asset, b: Asset) => Asset;
+    /**
+     * Return asset precision.
+     */
+    getPrecision: () => 3 | 6;
+    /**
+     * Return a string representation of this asset, e.g. `42.000 HIVE`.
+     */
+    toString: () => string;
+    /**
+     * Return a new Asset instance with amount added.
+     */
+    add: (amount: number | Asset | string) => Asset;
+    /**
+     * Return a new Asset instance with amount subtracted.
+     */
+    subtract: (amount: number | Asset | string) => Asset;
+    /**
+     * Return a new Asset with the amount multiplied by factor.
+     */
+    multiply: (factor: number | Asset | string) => Asset;
+    /**
+     * Return a new Asset with the amount divided.
+     */
+    divide: (divisor: number | Asset | string) => Asset;
+    /**
+     * For JSON serialization, same as toString().
+     */
+    toJSON: () => string;
+}
+export declare class Price {
+    /**
+     * @param base  - represents a value of the price object to be expressed relatively to quote
+     *                asset. Cannot have amount == 0 if you want to build valid price.
+     * @param quote - represents an relative asset. Cannot have amount == 0, otherwise
+     *                asertion fail.
+     *
+     * Both base and quote shall have different symbol defined.
+     */
+    base: Asset;
+    quote: Asset;
+    constructor(base: Asset, quote: Asset);
+    /**
+     * Convenience to create new Price.
+     */
+    static from: (value: PriceType) => Price;
+    /**
+     * Return a string representation of this price pair.
+     */
+    toString: () => string;
+    /**
+     * Return a new Asset with the price converted between the symbols in the pair.
+     * Throws if passed asset symbol is not base or quote.
+     */
+    convert: (asset: Asset) => Asset;
+}

package/lib/utils/assets.utils.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Price = exports.Asset = void 0;
+const assert_1 = __importDefault(require("assert"));
+class Asset {
+    constructor(amount, symbol) {
+        /**
+         * Return asset precision.
+         */
+        this.getPrecision = () => {
+            switch (this.symbol) {
+                case 'TESTS':
+                case 'TBD':
+                case 'HIVE':
+                case 'HBD':
+                case 'SBD':
+                case 'STEEM':
+                    return 3;
+                case 'VESTS':
+                    return 6;
+            }
+        };
+        /**
+         * Return a string representation of this asset, e.g. `42.000 HIVE`.
+         */
+        this.toString = () => {
+            return this.amount.toFixed(this.getPrecision()) + ' ' + this.symbol;
+        };
+        /**
+         * Return a new Asset instance with amount added.
+         */
+        this.add = (amount) => {
+            const other = Asset.from(amount, this.symbol);
+            (0, assert_1.default)(this.symbol === other.symbol, 'can not add with different symbols');
+            return new Asset(this.amount + other.amount, this.symbol);
+        };
+        /**
+         * Return a new Asset instance with amount subtracted.
+         */
+        this.subtract = (amount) => {
+            const other = Asset.from(amount, this.symbol);
+            (0, assert_1.default)(this.symbol === other.symbol, 'can not subtract with different symbols');
+            return new Asset(this.amount - other.amount, this.symbol);
+        };
+        /**
+         * Return a new Asset with the amount multiplied by factor.
+         */
+        this.multiply = (factor) => {
+            const other = Asset.from(factor, this.symbol);
+            (0, assert_1.default)(this.symbol === other.symbol, 'can not multiply with different symbols');
+            return new Asset(this.amount * other.amount, this.symbol);
+        };
+        /**
+         * Return a new Asset with the amount divided.
+         */
+        this.divide = (divisor) => {
+            const other = Asset.from(divisor, this.symbol);
+            (0, assert_1.default)(this.symbol === other.symbol, 'can not divide with different symbols');
+            return new Asset(this.amount / other.amount, this.symbol);
+        };
+        /**
+         * For JSON serialization, same as toString().
+         */
+        this.toJSON = () => {
+            return this.toString();
+        };
+        this.amount = amount;
+        this.symbol = symbol;
+    }
+}
+exports.Asset = Asset;
+/**
+ * Create a new Asset instance from a string, e.g. `42.000 HIVE`.
+ */
+Asset.fromString = (str, expectedSymbol) => {
+    const _a = str.split(' ');
+    const amountString = _a[0];
+    const symbol = _a[1];
+    if (!['HIVE', 'VESTS', 'HBD', 'TESTS', 'TBD', 'SBD', 'STEEM'].includes(symbol)) {
+        throw new Error('Invalid asset symbol: ' + symbol);
+    }
+    if (expectedSymbol && symbol !== expectedSymbol) {
+        throw new Error('Invalid asset, expected symbol: ' + expectedSymbol + ' got: ' + symbol);
+    }
+    const amount = Number.parseFloat(amountString);
+    if (!Number.isFinite(amount)) {
+        throw new Error('Invalid asset amount: ' + amountString);
+    }
+    return new Asset(amount, symbol);
+};
+/**
+ * Convenience to create new Asset.
+ * @param symbol Symbol to use when created from number. Will also be used to validate
+ *               the asset, throws if the passed value has a different symbol than this.
+ */
+Asset.from = (value, symbol) => {
+    if (value instanceof Asset) {
+        if (symbol && value.symbol !== symbol) {
+            throw new Error('Invalid asset, expected symbol: ' + symbol + ' got: ' + value.symbol);
+        }
+        return value;
+    }
+    else if (typeof value === 'number' && Number.isFinite(value)) {
+        return new Asset(value, symbol || 'STEEM');
+    }
+    else if (typeof value === 'string') {
+        return Asset.fromString(value, symbol);
+    }
+    else {
+        throw new Error("Invalid asset '" + String(value) + "'");
+    }
+};
+/**
+ * Return the smaller of the two assets.
+ */
+Asset.min = (a, b) => {
+    (0, assert_1.default)(a.symbol === b.symbol, 'can not compare assets with different symbols');
+    return a.amount < b.amount ? a : b;
+};
+/**
+ * Return the larger of the two assets.
+ */
+Asset.max = (a, b) => {
+    (0, assert_1.default)(a.symbol === b.symbol, 'can not compare assets with different symbols');
+    return a.amount > b.amount ? a : b;
+};
+class Price {
+    constructor(base, quote) {
+        /**
+         * Return a string representation of this price pair.
+         */
+        this.toString = () => {
+            return this.base + ':' + this.quote;
+        };
+        /**
+         * Return a new Asset with the price converted between the symbols in the pair.
+         * Throws if passed asset symbol is not base or quote.
+         */
+        this.convert = (asset) => {
+            if (asset.symbol === this.base.symbol) {
+                (0, assert_1.default)(this.base.amount > 0);
+                return new Asset((asset.amount * this.quote.amount) / this.base.amount, this.quote.symbol);
+            }
+            else if (asset.symbol === this.quote.symbol) {
+                (0, assert_1.default)(this.quote.amount > 0);
+                return new Asset((asset.amount * this.base.amount) / this.quote.amount, this.base.symbol);
+            }
+            else {
+                throw new Error('Can not convert ' + asset + ' with ' + this);
+            }
+        };
+        this.base = base;
+        this.quote = quote;
+        (0, assert_1.default)(base.amount !== 0 && quote.amount !== 0, 'base and quote assets must be non-zero');
+        (0, assert_1.default)(base.symbol !== quote.symbol, 'base and quote can not have the same symbol');
+    }
+}
+exports.Price = Price;
+/**
+ * Convenience to create new Price.
+ */
+Price.from = (value) => {
+    if (value instanceof Price) {
+        return value;
+    }
+    else {
+        return new Price(Asset.from(value.base), Asset.from(value.quote));
+    }
+};

package/lib/utils/crypto.utils.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const isWif: (privWif: string | Buffer) => boolean;

package/lib/utils/crypto.utils.js

@@ -0,0 +1,58 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWif = void 0;
+const bs58 = __importStar(require("bs58"));
+const crypto_js_1 = require("crypto-js");
+const sha256 = (input) => {
+    if (typeof input !== 'string') {
+        input = crypto_js_1.lib.WordArray.create(input);
+    }
+    const hash = Buffer.from((0, crypto_js_1.SHA256)(input).toString(CryptoJS.enc.Hex), 'hex');
+    return hash;
+};
+const ripemd160 = (input) => {
+    // return crypto.createHash('ripemd160').update(input).digest()
+    if (typeof input !== 'string') {
+        input = CryptoJS.lib.WordArray.create(input);
+    }
+    const hash = Buffer.from((0, crypto_js_1.RIPEMD160)(input).toString(CryptoJS.enc.Hex), 'hex');
+    return hash;
+};
+const isWif = (privWif) => {
+    try {
+        const bufWif = new Buffer(bs58.decode(privWif));
+        const privKey = bufWif.slice(0, -4);
+        const checksum = bufWif.slice(-4);
+        let newChecksum = sha256(privKey);
+        newChecksum = sha256(newChecksum);
+        newChecksum = newChecksum.slice(0, 4);
+        return checksum.toString() === newChecksum.toString();
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.isWif = isWif;

package/lib/utils/history-filters.utils.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Make bitmask filter to be used with getAccountHistory call
+ * @param allowedOperations Array of operations index numbers
+ */
+declare function makeBitMaskFilter(allowedOperations: number[]): any;
+export declare const HistoryFiltersUtils: {
+    operationOrders: {
+        vote: number;
+        comment: number;
+        transfer: number;
+        transfer_to_vesting: number;
+        withdraw_vesting: number;
+        limit_order_create: number;
+        limit_order_cancel: number;
+        feed_publish: number;
+        convert: number;
+        account_create: number;
+        account_update: number;
+        witness_update: number;
+        account_witness_vote: number;
+        account_witness_proxy: number;
+        pow: number;
+        custom: number;
+        report_over_production: number;
+        delete_comment: number;
+        custom_json: number;
+        comment_options: number;
+        set_withdraw_vesting_route: number;
+        limit_order_create2: number;
+        claim_account: number;
+        create_claimed_account: number;
+        request_account_recovery: number;
+        recover_account: number;
+        change_recovery_account: number;
+        escrow_transfer: number;
+        escrow_dispute: number;
+        escrow_release: number;
+        pow2: number;
+        escrow_approve: number;
+        transfer_to_savings: number;
+        transfer_from_savings: number;
+        cancel_transfer_from_savings: number;
+        custom_binary: number;
+        decline_voting_rights: number;
+        reset_account: number;
+        set_reset_account: number;
+        claim_reward_balance: number;
+        delegate_vesting_shares: number;
+        account_create_with_delegation: number;
+        witness_set_properties: number;
+        account_update2: number;
+        create_proposal: number;
+        update_proposal_votes: number;
+        remove_proposal: number;
+        update_proposal: number;
+        collateralized_convert: number;
+        recurrent_transfer: number;
+        fill_convert_request: number;
+        author_reward: number;
+        curation_reward: number;
+        comment_reward: number;
+        liquidity_reward: number;
+        interest: number;
+        fill_vesting_withdraw: number;
+        fill_order: number;
+        shutdown_witness: number;
+        fill_transfer_from_savings: number;
+        hardfork: number;
+        comment_payout_update: number;
+        return_vesting_delegation: number;
+        comment_benefactor_reward: number;
+        producer_reward: number;
+        clear_null_account_balance: number;
+        proposal_pay: number;
+        sps_fund: number;
+        hardfork_hive: number;
+        hardfork_hive_restore: number;
+        delayed_voting: number;
+        consolidate_treasury_balance: number;
+        effective_comment_vote: number;
+        ineffective_delete_comment: number;
+        sps_convert: number;
+        expired_account_notification: number;
+        changed_recovery_account: number;
+        transfer_to_vesting_completed: number;
+        pow_reward: number;
+        vesting_shares_split: number;
+        account_created: number;
+        fill_collateralized_convert_request: number;
+        system_warning: number;
+        fill_recurrent_transfer: number;
+        failed_recurrent_transfer: number;
+    };
+    makeBitMaskFilter: typeof makeBitMaskFilter;
+};
+export {};

package/lib/utils/history-filters.utils.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryFiltersUtils = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const operationOrders = {
+    vote: 0,
+    // tslint:disable-next-line: object-literal-sort-keys
+    comment: 1,
+    transfer: 2,
+    transfer_to_vesting: 3,
+    withdraw_vesting: 4,
+    limit_order_create: 5,
+    limit_order_cancel: 6,
+    feed_publish: 7,
+    convert: 8,
+    account_create: 9,
+    account_update: 10,
+    witness_update: 11,
+    account_witness_vote: 12,
+    account_witness_proxy: 13,
+    pow: 14,
+    custom: 15,
+    report_over_production: 16,
+    delete_comment: 17,
+    custom_json: 18,
+    comment_options: 19,
+    set_withdraw_vesting_route: 20,
+    limit_order_create2: 21,
+    claim_account: 22,
+    create_claimed_account: 23,
+    request_account_recovery: 24,
+    recover_account: 25,
+    change_recovery_account: 26,
+    escrow_transfer: 27,
+    escrow_dispute: 28,
+    escrow_release: 29,
+    pow2: 30,
+    escrow_approve: 31,
+    transfer_to_savings: 32,
+    transfer_from_savings: 33,
+    cancel_transfer_from_savings: 34,
+    custom_binary: 35,
+    decline_voting_rights: 36,
+    reset_account: 37,
+    set_reset_account: 38,
+    claim_reward_balance: 39,
+    delegate_vesting_shares: 40,
+    account_create_with_delegation: 41,
+    witness_set_properties: 42,
+    account_update2: 43,
+    create_proposal: 44,
+    update_proposal_votes: 45,
+    remove_proposal: 46,
+    update_proposal: 47,
+    collateralized_convert: 48,
+    recurrent_transfer: 49,
+    // virtual ops
+    fill_convert_request: 50,
+    author_reward: 51,
+    curation_reward: 52,
+    comment_reward: 53,
+    liquidity_reward: 54,
+    interest: 55,
+    fill_vesting_withdraw: 56,
+    fill_order: 57,
+    shutdown_witness: 58,
+    fill_transfer_from_savings: 59,
+    hardfork: 60,
+    comment_payout_update: 61,
+    return_vesting_delegation: 62,
+    comment_benefactor_reward: 63,
+    producer_reward: 64,
+    clear_null_account_balance: 65,
+    proposal_pay: 66,
+    sps_fund: 67,
+    hardfork_hive: 68,
+    hardfork_hive_restore: 69,
+    delayed_voting: 70,
+    consolidate_treasury_balance: 71,
+    effective_comment_vote: 72,
+    ineffective_delete_comment: 73,
+    sps_convert: 74,
+    expired_account_notification: 75,
+    changed_recovery_account: 76,
+    transfer_to_vesting_completed: 77,
+    pow_reward: 78,
+    vesting_shares_split: 79,
+    account_created: 80,
+    fill_collateralized_convert_request: 81,
+    system_warning: 82,
+    fill_recurrent_transfer: 83,
+    failed_recurrent_transfer: 84,
+};
+/**
+ * Make bitmask filter to be used with getAccountHistory call
+ * @param allowedOperations Array of operations index numbers
+ */
+function makeBitMaskFilter(allowedOperations) {
+    return allowedOperations
+        .map((value) => jsbi_1.default.notEqual(value, jsbi_1.default.BigInt(0)) ? value.toString() : null)
+        .reduce(redFunction, [jsbi_1.default.BigInt(0), jsbi_1.default.BigInt(0)]);
+}
+const redFunction = ([low, high], allowedOperation) => {
+    if (allowedOperation < 64) {
+        return [
+            jsbi_1.default.bitwiseOr(low, jsbi_1.default.leftShift(jsbi_1.default.BigInt(1), jsbi_1.default.BigInt(allowedOperation))),
+            high,
+        ];
+    }
+    else {
+        return [
+            low,
+            jsbi_1.default.bitwiseOr(high, jsbi_1.default.leftShift(jsbi_1.default.BigInt(1), jsbi_1.default.BigInt(allowedOperation - 64))),
+        ];
+    }
+};
+exports.HistoryFiltersUtils = { operationOrders, makeBitMaskFilter };

package/lib/utils/keys.utils.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPublicKeyFromPrivateKeyString = void 0;
-const dhive_1 = require("@hiveio/dhive");
+const hive_tx_1 = require("hive-tx");
 const getPublicKeyFromPrivateKeyString = (privateKeyS) => {
     try {
-        const privateKey = dhive_1.PrivateKey.fromString(privateKeyS);
+        const privateKey = hive_tx_1.PrivateKey.fromString(privateKeyS);
         const publicKey = privateKey.createPublic();
         return publicKey.toString();
     }

package/lib/utils/transfer.utils.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPrivateKeysMemoValidationWarning = void 0;
-const dhive_1 = require("@hiveio/dhive");
+const crypto_utils_1 = require("./crypto.utils");
 const keys_utils_1 = require("./keys.utils");
 const getPrivateKeysMemoValidationWarning = (memo) => {
     const memoTemp = memo.startsWith('#')
@@ -11,7 +11,7 @@ const getPrivateKeysMemoValidationWarning = (memo) => {
     found = memoTemp.match(/[\w\d]{51,52}/g);
     if (found) {
         for (const word of found) {
-            if (dhive_1.cryptoUtils.isWif(word) && word.length === 51) {
+            if ((0, crypto_utils_1.isWif)(word) && word.length === 51) {
                 if ((0, keys_utils_1.getPublicKeyFromPrivateKeyString)(word))
                     return true;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hive-keychain-commons",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "Platform-agnostic functions used in Hive Keychain mobile and extensions",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -36,8 +36,11 @@
   },
   "homepage": "https://github.com/stoodkev/hive-keychain-commons#readme",
   "devDependencies": {
+    "@types/bs58": "^4.0.4",
     "@types/bytebuffer": "^5.0.44",
+    "@types/crypto-js": "^4.2.2",
     "@types/node": "^18.11.19",
+    "@types/secp256k1": "^4.0.6",
     "prettier": "^2.4.1",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
@@ -45,7 +48,12 @@
   },
   "dependencies": {
     "@hiveio/dhive": "^1.2.8",
+    "bs58": "^4.0.1",
+    "crypto-js": "^4.2.0",
+    "hive-tx": "^6.0.4",
+    "jsbi": "^4.3.0",
     "moment": "^2.30.1",
+    "secp256k1": "^5.0.1",
     "winston": "^3.8.1",
     "winston-daily-rotate-file": "^4.7.1"
   }