@witnet/sdk 1.0.0-beta.0

package/dist/src/lib/crypto/utils.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXprv = exports.BigMath = exports.Signature = exports.RecoverableSignature = exports.PublicKeyHash = exports.PublicKey = exports.bech32 = void 0;
+exports.decipherXprv = decipherXprv;
+exports.selectUtxos = selectUtxos;
+exports.sha256 = sha256;
+exports.totalCoins = totalCoins;
+const secp256k1 = require("secp256k1");
+const bech32_1 = require("bech32");
+const crypto_1 = require("crypto");
+const types_1 = require("./types");
+var bech32_2 = require("bech32");
+Object.defineProperty(exports, "bech32", { enumerable: true, get: function () { return bech32_2.bech32; } });
+var types_2 = require("./types");
+Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return types_2.PublicKey; } });
+Object.defineProperty(exports, "PublicKeyHash", { enumerable: true, get: function () { return types_2.PublicKeyHash; } });
+Object.defineProperty(exports, "RecoverableSignature", { enumerable: true, get: function () { return types_2.RecoverableSignature; } });
+Object.defineProperty(exports, "Signature", { enumerable: true, get: function () { return types_2.Signature; } });
+exports.BigMath = {
+    max(value, ...values) {
+        for (const v of values)
+            if (v > value)
+                value = v;
+        return value;
+    },
+};
+const CHAIN_CODE_LENGTH = 32;
+const DEPTH_LENGTH = 1;
+const KEY_LENGTH = 33;
+const KEY_PATH_LENGTH = 4;
+const BECH32_LIMIT = (DEPTH_LENGTH
+    + ((Math.pow(256, DEPTH_LENGTH) - 1) * KEY_PATH_LENGTH)
+    + CHAIN_CODE_LENGTH
+    + KEY_LENGTH);
+const getExpectedDataLength = (depth) => (DEPTH_LENGTH
+    + depth * KEY_PATH_LENGTH
+    + CHAIN_CODE_LENGTH
+    + KEY_LENGTH);
+function decipherXprv(slip32, passwd) {
+    const { prefix, words } = bech32_1.bech32.decode(slip32, BECH32_LIMIT);
+    if (prefix !== "xprv") {
+        throw Error(`Invalid XPRV header: "${prefix}" != "xprv"`);
+    }
+    const buffer = new Uint8Array(bech32_1.bech32.fromWords(words)).buffer;
+    const iv = buffer.slice(0, 16);
+    const salt = buffer.slice(16, 48);
+    const data = buffer.slice(48);
+    const key = (0, crypto_1.pbkdf2Sync)(passwd, Buffer.from(salt), 10000, 32, 'sha256');
+    const decipher = (0, crypto_1.createDecipheriv)("aes-256-cbc", key, Buffer.from(iv));
+    let decrypted = decipher.update(Buffer.from(data), undefined, 'utf-8');
+    decrypted += decipher.final('utf-8');
+    return decrypted;
+}
+const parseXprv = (slip32) => {
+    // decode slip32 string
+    const { prefix, words } = bech32_1.bech32.decode(slip32, BECH32_LIMIT);
+    const bytes = bech32_1.bech32.fromWords(words);
+    // check prefix
+    if (prefix !== "xprv") {
+        throw Error(`Invalid XPRV: bad header: "${prefix}" != "xprv"`);
+    }
+    // check expected data length
+    const depth = bytes[0];
+    if (depth !== 0) {
+        throw Error(`Invalid XPRV: not a master private key (depth: ${depth})`);
+    }
+    const expectedLength = getExpectedDataLength(depth);
+    if (bytes.length !== expectedLength) {
+        throw Error("Invalid XPRV: bad data length"
+            + `(expected: ${expectedLength}, was: ${bytes.length}`);
+    }
+    const buffer = new Uint8Array(bytes).buffer;
+    // extract key path (32-bit unsigned integers, big endian)
+    const keyPath = [];
+    const keyPathView = new DataView(buffer, DEPTH_LENGTH, depth * KEY_PATH_LENGTH);
+    for (let i = 0; i < depth; i++) {
+        keyPath.push((keyPathView.getUint32(i * KEY_PATH_LENGTH, false)));
+    }
+    // extract chain code
+    const chainCode = new Uint8Array(CHAIN_CODE_LENGTH);
+    const chainCodeOffset = DEPTH_LENGTH + depth * KEY_PATH_LENGTH;
+    const chainCodeView = new DataView(buffer, chainCodeOffset, CHAIN_CODE_LENGTH);
+    for (let i = 0; i < chainCode.length; i++) {
+        chainCode[i] = (chainCodeView.getUint8(i));
+    }
+    // extract key bytes
+    const privateKey = new Uint8Array(KEY_LENGTH);
+    const privateKeyView = new DataView(buffer, chainCodeOffset + CHAIN_CODE_LENGTH);
+    for (let i = 0; i < privateKey.length; i++) {
+        privateKey[i] = (privateKeyView.getUint8(i));
+    }
+    // check if private or public key are valid
+    if (privateKey[0] !== 0 || !secp256k1.privateKeyVerify(privateKey.slice(1))) {
+        throw Error(`Malformed slip32: not a private key`);
+    }
+    return {
+        chainCode,
+        keyPath,
+        privateKey: privateKey.slice(1),
+    };
+};
+exports.parseXprv = parseXprv;
+function selectUtxos(specs) {
+    const strategy = specs.strategy || types_1.UtxoSelectionStrategy.SlimFit;
+    switch (strategy) {
+        case types_1.UtxoSelectionStrategy.BigFirst:
+        case types_1.UtxoSelectionStrategy.SlimFit:
+            specs.utxos = specs.utxos.sort((a, b) => (a.value > b.value) ? -1 : ((a.value < b.value) ? 1 : 0));
+            break;
+        case types_1.UtxoSelectionStrategy.Random:
+            const len = specs.utxos.length;
+            for (let i = 0; i < len; i++) {
+                const index = Math.floor(Math.random() * (len - i));
+                const tmp = specs.utxos[index];
+                specs.utxos[index] = specs.utxos[len - i - 1];
+                specs.utxos[len - i - 1] = tmp;
+            }
+            break;
+        case types_1.UtxoSelectionStrategy.SmallFirst:
+            specs.utxos = specs.utxos.sort((a, b) => (a.value < b.value) ? -1 : ((a.value > b.value) ? 1 : 0));
+            break;
+    }
+    // filter locked UTXOs:
+    const now = Math.floor(Date.now() / 1000);
+    specs.utxos = specs.utxos.filter(utxo => utxo.timelock <= now);
+    // if target value is specified, filter spare UTXOs
+    const pedros = specs?.value?.pedros;
+    if (pedros) {
+        if (strategy === types_1.UtxoSelectionStrategy.SlimFit) {
+            const slimFitIndex = specs.utxos.findIndex(utxo => utxo.value <= pedros);
+            if (slimFitIndex >= 1) {
+                return specs.utxos.slice(slimFitIndex - 1, slimFitIndex);
+            }
+        }
+        let covered = 0n;
+        return specs.utxos.filter(utxo => {
+            const filter = covered <= pedros;
+            covered += BigInt(utxo.value);
+            return filter;
+        });
+    }
+    else {
+        return specs.utxos;
+    }
+}
+function sha256(buffer) {
+    const hash = (0, crypto_1.createHash)('sha256');
+    hash.update(buffer);
+    return hash.digest();
+}
+function totalCoins(balance) {
+    return types_1.Coins.fromPedros(BigInt(balance.locked)
+        + BigInt(balance.staked)
+        + BigInt(balance.unlocked));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/crypto/utils.ts"],"names":[],"mappings":"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","sourcesContent":["const secp256k1 = require(\"secp256k1\")\r\n\r\nimport { bech32 } from 'bech32'\r\nimport { createDecipheriv, createHash, pbkdf2Sync } from 'crypto'\r\nimport { Balance } from '../types'\r\nimport { Coins, Utxo, UtxoSelectionStrategy } from './types'\r\n\r\nexport { bech32 } from 'bech32'\r\n\r\nexport { PrivateKey, PublicKey, PublicKeyHash, KeyedSignature, RecoverableSignature, Signature } from \"./types\"\r\n\r\nexport const BigMath = {\r\n    max(value: bigint, ...values: bigint[]): bigint {\r\n        for (const v of values)\r\n            if (v > value) value = v\r\n                return value\r\n    },\r\n}\r\n\r\nconst CHAIN_CODE_LENGTH = 32\r\nconst DEPTH_LENGTH = 1\r\nconst KEY_LENGTH = 33\r\nconst KEY_PATH_LENGTH = 4\r\n\r\nconst BECH32_LIMIT = (\r\n    DEPTH_LENGTH \r\n        + ((Math.pow(256, DEPTH_LENGTH) - 1) * KEY_PATH_LENGTH) \r\n        + CHAIN_CODE_LENGTH \r\n        + KEY_LENGTH\r\n);\r\n\r\nconst getExpectedDataLength = (depth: number) => (\r\n    DEPTH_LENGTH\r\n        + depth * KEY_PATH_LENGTH\r\n        + CHAIN_CODE_LENGTH\r\n        + KEY_LENGTH\r\n);\r\n\r\nexport function decipherXprv(slip32: string, passwd: string): string {\r\n    const { prefix, words } = bech32.decode(slip32, BECH32_LIMIT)\r\n    if (prefix !== \"xprv\") {\r\n        throw Error(`Invalid XPRV header: \"${prefix}\" != \"xprv\"`)\r\n    }\r\n    const buffer = new Uint8Array(bech32.fromWords(words)).buffer\r\n    const iv = buffer.slice(0, 16)\r\n    const salt = buffer.slice(16, 48)\r\n    const data = buffer.slice(48)\r\n    const key = pbkdf2Sync(passwd, Buffer.from(salt), 10000, 32, 'sha256')    \r\n    const decipher = createDecipheriv(\"aes-256-cbc\", key, Buffer.from(iv))\r\n    let decrypted = decipher.update(Buffer.from(data), undefined, 'utf-8')\r\n    decrypted += decipher.final('utf-8')\r\n    return decrypted\r\n}\r\n\r\nexport const parseXprv = (slip32: string): {\r\n    chainCode: Uint8Array,\r\n    keyPath: Array<number>,\r\n    privateKey: Uint8Array,\r\n} => {\r\n    // decode slip32 string\r\n    const { prefix, words } = bech32.decode(slip32, BECH32_LIMIT)\r\n    const bytes = bech32.fromWords(words)\r\n\r\n    // check prefix\r\n    if (prefix !== \"xprv\") {\r\n        throw Error(`Invalid XPRV: bad header: \"${prefix}\" != \"xprv\"`)\r\n    }\r\n\r\n    // check expected data length\r\n    const depth = bytes[0]\r\n    if (depth !== 0) {\r\n        throw Error(`Invalid XPRV: not a master private key (depth: ${depth})`)\r\n    }\r\n    const expectedLength = getExpectedDataLength(depth)\r\n    if (bytes.length !== expectedLength) {\r\n        throw Error(\r\n            \"Invalid XPRV: bad data length\"\r\n                + `(expected: ${expectedLength}, was: ${bytes.length}`\r\n        )\r\n    }\r\n    const buffer = new Uint8Array(bytes).buffer\r\n\r\n    // extract key path (32-bit unsigned integers, big endian)\r\n    const keyPath: Array<number> = []\r\n    const keyPathView = new DataView(buffer, DEPTH_LENGTH, depth * KEY_PATH_LENGTH)\r\n    for (let i = 0; i < depth; i++) {\r\n        keyPath.push((keyPathView.getUint32(i * KEY_PATH_LENGTH, false)))\r\n    }\r\n\r\n    // extract chain code\r\n    const chainCode: Uint8Array = new Uint8Array(CHAIN_CODE_LENGTH)\r\n    const chainCodeOffset = DEPTH_LENGTH + depth * KEY_PATH_LENGTH\r\n    const chainCodeView = new DataView(buffer, chainCodeOffset, CHAIN_CODE_LENGTH)\r\n    for (let i = 0; i < chainCode.length; i++) {\r\n        chainCode[i] = (chainCodeView.getUint8(i))\r\n    }\r\n\r\n    // extract key bytes\r\n    const privateKey: Uint8Array = new Uint8Array(KEY_LENGTH)\r\n    const privateKeyView = new DataView(buffer, chainCodeOffset + CHAIN_CODE_LENGTH)\r\n    for (let i = 0; i < privateKey.length; i++) {\r\n        privateKey[i] = (privateKeyView.getUint8(i))\r\n    }\r\n\r\n    // check if private or public key are valid\r\n    if (privateKey[0] !== 0 || !secp256k1.privateKeyVerify(privateKey.slice(1))) {\r\n        throw Error(`Malformed slip32: not a private key`)\r\n    } \r\n\r\n    return {\r\n        chainCode,\r\n        keyPath,\r\n        privateKey: privateKey.slice(1),\r\n    }\r\n};\r\n\r\nexport function selectUtxos(specs: { \r\n    utxos: Array<Utxo>, \r\n    value?: Coins, \r\n    strategy?: UtxoSelectionStrategy, \r\n}): Array<Utxo> {\r\n    const strategy = specs.strategy || UtxoSelectionStrategy.SlimFit\r\n    switch (strategy) {\r\n        case UtxoSelectionStrategy.BigFirst:\r\n        case UtxoSelectionStrategy.SlimFit:\r\n            specs.utxos = specs.utxos.sort((a, b) => (a.value > b.value) ? -1 : ((a.value < b.value) ? 1 : 0))\r\n            break\r\n\r\n        case UtxoSelectionStrategy.Random:\r\n            const len = specs.utxos.length\r\n            for (let i = 0; i < len; i ++) {\r\n                const index = Math.floor(Math.random() * (len - i))\r\n                const tmp = specs.utxos[index]\r\n                specs.utxos[index] = specs.utxos[len - i - 1]\r\n                specs.utxos[len - i - 1] = tmp\r\n            }\r\n            break\r\n\r\n        case UtxoSelectionStrategy.SmallFirst:\r\n            specs.utxos = specs.utxos.sort((a, b) => (a.value < b.value) ? -1 : ((a.value > b.value) ? 1 : 0))\r\n            break\r\n    }\r\n    \r\n    // filter locked UTXOs:\r\n    const now = Math.floor(Date.now() / 1000)\r\n    specs.utxos = specs.utxos.filter(utxo => utxo.timelock <= now)\r\n\r\n    // if target value is specified, filter spare UTXOs\r\n    const pedros = specs?.value?.pedros\r\n    if (pedros) {\r\n        if (strategy === UtxoSelectionStrategy.SlimFit) {\r\n            const slimFitIndex = specs.utxos.findIndex(utxo => utxo.value <= pedros)\r\n            if (slimFitIndex >= 1) {\r\n                return specs.utxos.slice(slimFitIndex - 1, slimFitIndex)\r\n            }\r\n        }\r\n        let covered: bigint = 0n \r\n        return specs.utxos.filter(utxo => {\r\n            const filter = covered <= pedros\r\n            covered += BigInt(utxo.value)\r\n            return filter\r\n        })\r\n    } else {\r\n        return specs.utxos\r\n    }\r\n}\r\n\r\nexport function sha256(buffer: any) {\r\n    const hash = createHash('sha256')\r\n    hash.update(buffer)\r\n    return hash.digest()\r\n}\r\n\r\nexport function totalCoins(balance: Balance): Coins {\r\n    return Coins.fromPedros(\r\n        BigInt(balance.locked)\r\n            + BigInt(balance.staked)\r\n            + BigInt(balance.unlocked)\r\n    )\r\n}"]}

package/dist/src/lib/crypto/wallet.d.ts

@@ -0,0 +1,120 @@
+import { Balance, Network, QueryStakesOrder, StakeEntry } from "../types";
+import { IAccount, IBIP32, ICoinbase, IJsonRpcProvider, ISigner, IWallet } from "./interfaces";
+import { Coins, PublicKey, PublicKeyHashString, Utxo, UtxoCacheInfo, UtxoSelectionStrategy } from "./types";
+export declare class Wallet implements IWallet {
+    protected root: IBIP32;
+    protected _accounts: Array<IAccount>;
+    readonly coinbase: ICoinbase;
+    readonly provider: IJsonRpcProvider;
+    strategy: UtxoSelectionStrategy;
+    /**
+     * Create a Wallet by reading the XPRV master key from the WITNET_SDK_WALLET_MASTER_KEY environment variable.
+     * @param specs Wallet creation parameters.
+     */
+    static fromEnv(options: {
+        /**
+         * Password to decrypt the XPRV master key read from environment, in case it's encrypted.
+         */
+        passwd?: string;
+        /**
+         * Number of consecutive accounts with no funds before stopping derivation of new Wallet accounts.
+         */
+        gap?: number;
+        /**
+         * Maximum number of accounts to derive.
+         */
+        limit?: number;
+        /**
+         * Specific Wit/RPC provider to use for interacting with the Witnet network.
+         */
+        provider?: IJsonRpcProvider;
+        /**
+         * UTXO selection strategy when building transactions out of this wallet (default: UtxoSelectionStrategy.SmallFirst).
+         */
+        strategy?: UtxoSelectionStrategy;
+        /**
+         * Only derive accounts that hold some unlocked balance of $WIT.
+         */
+        onlyWithFunds?: boolean;
+    }): Promise<Wallet>;
+    /**
+     * Create a Wallet by using passed XPRV master key.
+     * @param xprv Decrypted XPRV master key string.
+     * @param options Wallet creation parameters.
+     */
+    static fromXprv(xprv: string, options?: {
+        /**
+         * Number of consecutive accounts with no funds before stopping derivation of new Wallet accounts.
+         */
+        gap?: number;
+        /**
+         * Maximum number of accounts to derive.
+         */
+        limit?: number;
+        /**
+         * Specific Wit/RPC provider to use for interacting with the Witnet network.
+         */
+        provider?: IJsonRpcProvider;
+        /**
+         * UTXO selection strategy when building transactions out of this wallet (default: UtxoSelectionStrategy.SmallFirst).
+         */
+        strategy?: UtxoSelectionStrategy;
+        /**
+         * Only derive accounts holding some $WIT funds (either locked, staked or unlocked).
+         */
+        onlyWithFunds?: boolean;
+    }): Promise<Wallet>;
+    /**
+     * Create a Wallet by using passed XPRV master key.
+     * @param xprv Encrypted XPRV master key string.
+     * @param passwd Password to decipher the XPRV master key.
+     * @param options Wallet creation parameters.
+     */
+    static fromEncryptedXprv(xprv: string, passwd: string, options?: {
+        /**
+         * Number of consecutive accounts with no funds before stopping derivation of new Wallet accounts.
+         */
+        gap?: number;
+        /**
+         * Maximum number of accounts to derive.
+         */
+        limit?: number;
+        /**
+         * Specific Wit/RPC provider to use for interacting with the Witnet network.
+         */
+        provider?: IJsonRpcProvider;
+        /**
+         * UTXO selection strategy when building transactions out of this wallet (default: UtxoSelectionStrategy.SmallFirst).
+         */
+        strategy?: UtxoSelectionStrategy;
+        /**
+         * Only derive accounts holding some $WIT funds (either locked, staked or unlocked).
+         */
+        onlyWithFunds?: boolean;
+    }): Promise<Wallet>;
+    constructor(root: IBIP32, provider: IJsonRpcProvider, strategy?: UtxoSelectionStrategy);
+    get accounts(): Array<IAccount>;
+    get cacheInfo(): UtxoCacheInfo;
+    get changePkh(): PublicKeyHashString;
+    get network(): Network | undefined;
+    get pkh(): PublicKeyHashString;
+    get publicKey(): PublicKey;
+    addUtxos(...utxos: Array<Utxo>): {
+        excluded: Array<Utxo>;
+        included: Array<Utxo>;
+    };
+    consumeUtxos(...utxos: Array<Utxo>): Array<Utxo>;
+    getBalance(): Promise<Balance>;
+    getDelegatees(order?: QueryStakesOrder, leftJoin?: boolean): Promise<Array<StakeEntry>>;
+    getUtxos(reload?: boolean): Promise<Array<Utxo>>;
+    selectUtxos(specs?: {
+        value?: Coins;
+        reload?: boolean;
+        strategy?: UtxoSelectionStrategy;
+    }): Promise<Array<Utxo>>;
+    deriveAccounts(limit: number): Array<IAccount>;
+    exploreAccounts(limit?: number, gap?: number): Promise<Array<IAccount>>;
+    getAccount(pkh: PublicKeyHashString, gap?: number): IAccount | undefined;
+    getSigner(pkh?: PublicKeyHashString, gap?: number): ISigner | undefined;
+}
+//# sourceMappingURL=wallet.d.ts.map

package/dist/src/lib/crypto/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../../src/lib/crypto/wallet.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/crypto/wallet.js

@@ -0,0 +1,258 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wallet = void 0;
+const utils = __importStar(require("./utils"));
+const bip32_1 = __importDefault(require("bip32"));
+const ecc = __importStar(require("tiny-secp256k1"));
+const bip32 = (0, bip32_1.default)(ecc);
+const rpc_1 = require("../rpc");
+const types_1 = require("../types");
+const account_1 = require("./account");
+const coinbase_1 = require("./coinbase");
+const types_2 = require("./types");
+const DEFAULT_GAP = 20;
+class Wallet {
+    /**
+     * Create a Wallet by reading the XPRV master key from the WITNET_SDK_WALLET_MASTER_KEY environment variable.
+     * @param specs Wallet creation parameters.
+     */
+    static async fromEnv(options) {
+        const xprv = process.env.WITNET_SDK_WALLET_MASTER_KEY;
+        if (!xprv)
+            throw Error(`WITNET_SDK_WALLET_MASTER_KEY must be set on environment.`);
+        if (xprv.length > 117) {
+            if (!options.passwd)
+                throw Error(`Missing password for WITNET_SDK_WALLET_MASTER_KEY.`);
+            return Wallet.fromEncryptedXprv(xprv, options?.passwd, options);
+        }
+        else {
+            return Wallet.fromXprv(xprv, options);
+        }
+    }
+    /**
+     * Create a Wallet by using passed XPRV master key.
+     * @param xprv Decrypted XPRV master key string.
+     * @param options Wallet creation parameters.
+     */
+    static async fromXprv(xprv, options) {
+        const { chainCode, privateKey } = utils.parseXprv(xprv);
+        const root = bip32.fromPrivateKey(Buffer.from(privateKey), Buffer.from(chainCode));
+        const provider = options?.provider || (await rpc_1.JsonRpcProvider.fromEnv());
+        await provider.constants();
+        const wallet = new Wallet(root, provider, options?.strategy);
+        if (options?.onlyWithFunds) {
+            await wallet.exploreAccounts(options?.limit || 0, options?.gap);
+        }
+        else {
+            wallet.deriveAccounts(options?.limit || 1);
+        }
+        // load up utxos cache
+        await wallet.getUtxos(true);
+        return wallet;
+    }
+    /**
+     * Create a Wallet by using passed XPRV master key.
+     * @param xprv Encrypted XPRV master key string.
+     * @param passwd Password to decipher the XPRV master key.
+     * @param options Wallet creation parameters.
+     */
+    static async fromEncryptedXprv(xprv, passwd, options) {
+        return Wallet.fromXprv(utils.decipherXprv(xprv, passwd), options);
+    }
+    constructor(root, provider, strategy) {
+        this._accounts = [];
+        this.provider = provider;
+        this.coinbase = new coinbase_1.Coinbase(root, provider, strategy);
+        this.root = root;
+        this.strategy = strategy || types_2.UtxoSelectionStrategy.SmallFirst;
+        this.deriveAccounts(1);
+    }
+    get accounts() {
+        return this._accounts;
+    }
+    get cacheInfo() {
+        const info = { expendable: 0n, size: 0, timelock: Number.MAX_SAFE_INTEGER };
+        this.accounts?.forEach(account => {
+            const accountInfo = account.cacheInfo;
+            info.expendable += accountInfo.expendable;
+            info.size += accountInfo.size;
+            if (accountInfo.timelock !== 0 && accountInfo.timelock < info.timelock) {
+                info.timelock = accountInfo.timelock;
+            }
+        });
+        if (info.timelock === Number.MAX_SAFE_INTEGER)
+            info.timelock = 0;
+        return info;
+    }
+    get changePkh() {
+        return this.accounts.length > 0 ? this.accounts[0].changePkh : this.coinbase.pkh;
+    }
+    get network() {
+        return this.provider.network;
+    }
+    get pkh() {
+        return this.accounts.length > 0 ? this.accounts[0].pkh : this.coinbase.pkh;
+    }
+    get publicKey() {
+        return this.accounts.length > 0 ? this.accounts[0].publicKey : this.coinbase.publicKey;
+    }
+    addUtxos(...utxos) {
+        const included = [];
+        this.accounts.forEach(account => {
+            const _utxos = account.addUtxos(...utxos);
+            utxos = _utxos.excluded;
+            included.push(..._utxos.included);
+        });
+        return {
+            excluded: utxos,
+            included
+        };
+    }
+    consumeUtxos(...utxos) {
+        this.accounts.forEach(account => {
+            utxos = account.consumeUtxos(...utxos);
+        });
+        return utxos;
+    }
+    async getBalance() {
+        if (this._accounts.length > 0) {
+            return Promise
+                .all(this._accounts.map(async (acc) => {
+                const balance = await acc.getBalance();
+                // console.log(acc.index, acc.pkh, balance.unlocked); 
+                return balance;
+            }))
+                .then((balances) => {
+                return balances.reduce((prev, curr) => {
+                    // console.log("\nprev =>", prev.unlocked)
+                    // console.log("curr =>", curr.unlocked)
+                    return {
+                        locked: prev.locked + curr.locked,
+                        staked: prev.staked + curr.staked,
+                        unlocked: prev.unlocked + curr.unlocked,
+                    };
+                }, { locked: 0n, staked: 0n, unlocked: 0n });
+            });
+        }
+        else {
+            return this.coinbase.getBalance();
+        }
+    }
+    async getDelegatees(order, leftJoin = true) {
+        const records = [];
+        records.push(...await this.coinbase.getDelegatees(order));
+        await Promise.all(this._accounts.map(account => account.getDelegatees(order, leftJoin).then(entries => records.push(...entries))));
+        if (order) {
+            const reverse = order?.reverse ? (+1) : (-1);
+            return records.sort((a, b) => {
+                switch (order.by) {
+                    case types_1.StakesOrderBy.Coins: return ((a.value.coins < b.value.coins) ? 1 : ((a.value.coins > b.value.coins) ? -1 : 0)) * reverse;
+                    case types_1.StakesOrderBy.Mining: return (b.value.epochs.mining - a.value.epochs.mining) * reverse;
+                    case types_1.StakesOrderBy.Witnessing: return (b.value.epochs.witnessing - a.value.epochs.witnessing) * reverse;
+                    case types_1.StakesOrderBy.Nonce: return (b.value.nonce - a.value.nonce) * reverse;
+                }
+            });
+        }
+        return records;
+    }
+    async getUtxos(reload) {
+        return Promise
+            .all(this.accounts.map(account => account.getUtxos(reload)))
+            .then(async (utxoss) => {
+            // utxoss.push(await this.coinbase.getUtxos(reload))
+            return utxoss.flat();
+        });
+    }
+    async selectUtxos(specs) {
+        return this
+            .getUtxos(specs?.reload)
+            .then(utxos => utils.selectUtxos({ utxos, value: specs?.value, strategy: specs?.strategy || this.strategy }));
+    }
+    // ================================================================================================================
+    // --- IWallet ----------------------------------------------------------------------------------------------------
+    deriveAccounts(limit) {
+        if (limit > this._accounts.length) {
+            const startIndex = this._accounts.length > 0 ? this.accounts[this.accounts.length - 1].index + 1 : 0;
+            limit = limit - this._accounts.length;
+            for (let ix = 0; ix < limit; ix++) {
+                this._accounts.push(new account_1.Account(this.root, this.provider, startIndex + ix, this.strategy));
+            }
+        }
+        return this._accounts;
+    }
+    async exploreAccounts(limit = 0, gap = DEFAULT_GAP) {
+        if (limit === 0 || limit > this.accounts.length) {
+            const lastIndex = (x) => x.length > 0 ? x[x.length - 1].index + 1 : 0;
+            const startIndex = lastIndex(this.accounts);
+            for (let index = startIndex; index < lastIndex(this.accounts) + gap; index++) {
+                const account = new account_1.Account(this.root, this.provider, index, this.strategy);
+                if (utils.totalCoins(await account.getBalance()).pedros > 0n) {
+                    this.accounts.push(account);
+                    if (limit && this.accounts.length >= limit)
+                        break;
+                }
+            }
+        }
+        return this._accounts;
+    }
+    getAccount(pkh, gap) {
+        let account = this._accounts.find(account => account.internal.pkh === pkh || account.pkh === pkh);
+        if (!account) {
+            for (let index = 0; index < (gap || DEFAULT_GAP); index++) {
+                account = new account_1.Account(this.root, this.provider, index, this.strategy);
+                if (account.pkh === pkh || account.internal.pkh === pkh) {
+                    this._accounts.push(account);
+                    return account;
+                }
+            }
+            return undefined;
+        }
+        else {
+            return account;
+        }
+    }
+    getSigner(pkh, gap) {
+        if (!pkh)
+            return this.accounts[0]?.getSigner() || this.coinbase.getSigner(pkh);
+        const account = this.getAccount(pkh, gap);
+        return account?.getSigner(pkh) || this.coinbase.getSigner(pkh);
+    }
+}
+exports.Wallet = Wallet;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wallet.js","sourceRoot":"","sources":["../../../../src/lib/crypto/wallet.ts"],"names":[],"mappings":"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","sourcesContent":["import * as utils from \"./utils\"\r\n\r\nimport BIP32Factory from 'bip32';\r\nimport * as ecc from 'tiny-secp256k1';\r\nconst bip32 = BIP32Factory(ecc);\r\n\r\nimport { JsonRpcProvider } from \"../rpc\"\r\nimport { Balance, Network, QueryStakesOrder, StakeEntry, StakesOrderBy } from \"../types\"\r\nimport { Account } from \"./account\"\r\nimport { Coinbase } from \"./coinbase\"\r\nimport { IAccount, IBIP32, ICoinbase, IJsonRpcProvider, ISigner, IWallet } from \"./interfaces\"\r\nimport { Coins, PublicKey, PublicKeyHashString, Utxo, UtxoCacheInfo, UtxoSelectionStrategy } from \"./types\"\r\n\r\nconst DEFAULT_GAP = 20;\r\n\r\nexport class Wallet implements IWallet {\r\n    protected root: IBIP32;\r\n    \r\n    protected _accounts: Array<IAccount> = [];\r\n\r\n    public readonly coinbase: ICoinbase;\r\n    public readonly provider: IJsonRpcProvider;\r\n    public strategy: UtxoSelectionStrategy;\r\n\r\n    /**\r\n     * Create a Wallet by reading the XPRV master key from the WITNET_SDK_WALLET_MASTER_KEY environment variable.\r\n     * @param specs Wallet creation parameters.\r\n     */\r\n    static async fromEnv(options: {\r\n        /**\r\n         * Password to decrypt the XPRV master key read from environment, in case it's encrypted.\r\n         */\r\n        passwd?: string,\r\n        /**\r\n         * Number of consecutive accounts with no funds before stopping derivation of new Wallet accounts.\r\n         */\r\n        gap?: number,\r\n        /**\r\n         * Maximum number of accounts to derive. \r\n         */\r\n        limit?: number,\r\n        /**\r\n         * Specific Wit/RPC provider to use for interacting with the Witnet network.\r\n         */\r\n        provider?: IJsonRpcProvider, \r\n        /**\r\n         * UTXO selection strategy when building transactions out of this wallet (default: UtxoSelectionStrategy.SmallFirst).\r\n         */\r\n        strategy?: UtxoSelectionStrategy, \r\n        /**\r\n         * Only derive accounts that hold some unlocked balance of $WIT.\r\n         */\r\n        onlyWithFunds?: boolean,\r\n    }): Promise<Wallet> {\r\n        const xprv = process.env.WITNET_SDK_WALLET_MASTER_KEY\r\n        if (!xprv) throw Error(`WITNET_SDK_WALLET_MASTER_KEY must be set on environment.`)\r\n        if (xprv.length > 117) {\r\n            if (!options.passwd) throw Error(`Missing password for WITNET_SDK_WALLET_MASTER_KEY.`)\r\n            return Wallet.fromEncryptedXprv(xprv, options?.passwd, options)\r\n        } else {\r\n            return Wallet.fromXprv(xprv, options)\r\n        }\r\n    }\r\n    \r\n    /**\r\n     * Create a Wallet by using passed XPRV master key.\r\n     * @param xprv Decrypted XPRV master key string.\r\n     * @param options Wallet creation parameters.\r\n     */\r\n    static async fromXprv(\r\n        xprv: string,\r\n        options?: {\r\n            /**\r\n             * Number of consecutive accounts with no funds before stopping derivation of new Wallet accounts.\r\n             */\r\n            gap?: number,\r\n            /**\r\n             * Maximum number of accounts to derive. \r\n             */\r\n            limit?: number,\r\n            /**\r\n             * Specific Wit/RPC provider to use for interacting with the Witnet network.\r\n             */\r\n            provider?: IJsonRpcProvider, \r\n            /**\r\n             * UTXO selection strategy when building transactions out of this wallet (default: UtxoSelectionStrategy.SmallFirst).\r\n             */\r\n            strategy?: UtxoSelectionStrategy, \r\n            /**\r\n             * Only derive accounts holding some $WIT funds (either locked, staked or unlocked).\r\n             */\r\n            onlyWithFunds?: boolean,\r\n        }\r\n    ): Promise<Wallet> {\r\n        const { chainCode, privateKey } = utils.parseXprv(xprv);\r\n        const root = bip32.fromPrivateKey(Buffer.from(privateKey), Buffer.from(chainCode));\r\n        const provider = options?.provider || (await JsonRpcProvider.fromEnv())\r\n        await provider.constants()\r\n        const wallet = new Wallet(root, provider, options?.strategy)\r\n        if (options?.onlyWithFunds) {\r\n            await wallet.exploreAccounts(options?.limit || 0, options?.gap)\r\n        } else {\r\n            wallet.deriveAccounts(options?.limit || 1)\r\n        }\r\n        // load up utxos cache\r\n        await wallet.getUtxos(true)\r\n        return wallet\r\n    }\r\n\r\n    /**\r\n     * Create a Wallet by using passed XPRV master key.\r\n     * @param xprv Encrypted XPRV master key string.\r\n     * @param passwd Password to decipher the XPRV master key.\r\n     * @param options Wallet creation parameters.\r\n     */\r\n    static async fromEncryptedXprv(\r\n        xprv: string,\r\n        passwd: string,\r\n        options?: {\r\n            /**\r\n             * Number of consecutive accounts with no funds before stopping derivation of new Wallet accounts.\r\n             */\r\n            gap?: number,\r\n            /**\r\n             * Maximum number of accounts to derive. \r\n             */\r\n            limit?: number,\r\n            /**\r\n             * Specific Wit/RPC provider to use for interacting with the Witnet network.\r\n             */\r\n            provider?: IJsonRpcProvider, \r\n            /**\r\n             * UTXO selection strategy when building transactions out of this wallet (default: UtxoSelectionStrategy.SmallFirst).\r\n             */\r\n            strategy?: UtxoSelectionStrategy, \r\n            /**\r\n             * Only derive accounts holding some $WIT funds (either locked, staked or unlocked).\r\n             */\r\n            onlyWithFunds?: boolean,\r\n        }\r\n    ): Promise<Wallet> {\r\n        return Wallet.fromXprv(utils.decipherXprv(xprv, passwd), options)\r\n    }\r\n    \r\n    constructor(root: IBIP32, provider: IJsonRpcProvider, strategy?: UtxoSelectionStrategy) {\r\n        this.provider = provider\r\n        this.coinbase = new Coinbase(root, provider, strategy)\r\n        this.root = root\r\n        this.strategy = strategy || UtxoSelectionStrategy.SmallFirst\r\n        this.deriveAccounts(1)\r\n    }\r\n\r\n    public get accounts(): Array<IAccount> {\r\n        return this._accounts\r\n    }\r\n\r\n    public get cacheInfo(): UtxoCacheInfo {\r\n        const info: UtxoCacheInfo = { expendable: 0n, size: 0, timelock: Number.MAX_SAFE_INTEGER }\r\n        this.accounts?.forEach(account => {\r\n            const accountInfo = account.cacheInfo\r\n            info.expendable += accountInfo.expendable\r\n            info.size += accountInfo.size\r\n            if (accountInfo.timelock !== 0 && accountInfo.timelock < info.timelock) {\r\n                info.timelock = accountInfo.timelock\r\n            }\r\n        })\r\n        if (info.timelock === Number.MAX_SAFE_INTEGER) info.timelock = 0;\r\n        return info;\r\n    }\r\n\r\n    public get changePkh(): PublicKeyHashString {\r\n        return this.accounts.length > 0 ? this.accounts[0].changePkh : this.coinbase.pkh\r\n    }\r\n\r\n    public get network(): Network | undefined {\r\n        return this.provider.network\r\n    }\r\n\r\n    public get pkh(): PublicKeyHashString {\r\n        return this.accounts.length > 0 ? this.accounts[0].pkh : this.coinbase.pkh\r\n    }\r\n\r\n    public get publicKey(): PublicKey {\r\n        return this.accounts.length > 0 ? this.accounts[0].publicKey : this.coinbase.publicKey\r\n    }\r\n\r\n    public addUtxos(...utxos: Array<Utxo>): { excluded: Array<Utxo>, included: Array<Utxo> } {\r\n        const included: Array<Utxo> = []\r\n        this.accounts.forEach(account => {\r\n            const _utxos = account.addUtxos(...utxos)\r\n            utxos = _utxos.excluded\r\n            included.push(..._utxos.included)\r\n        })\r\n        return {\r\n            excluded: utxos,\r\n            included\r\n        }\r\n    }\r\n\r\n    public consumeUtxos(...utxos: Array<Utxo>): Array<Utxo> {\r\n        this.accounts.forEach(account => {\r\n            utxos = account.consumeUtxos(...utxos)\r\n        })\r\n        return utxos\r\n    }\r\n\r\n    public async getBalance(): Promise<Balance> {\r\n        if (this._accounts.length > 0) {\r\n            return Promise\r\n                .all(this._accounts.map(async (acc: IAccount) => { \r\n                    const balance = await acc.getBalance()\r\n                    // console.log(acc.index, acc.pkh, balance.unlocked); \r\n                    return balance }))\r\n                .then((balances: Array<Balance>) => {\r\n                    return balances.reduce((prev, curr) => {\r\n                        // console.log(\"\\nprev =>\", prev.unlocked)\r\n                        // console.log(\"curr =>\", curr.unlocked)\r\n                        return {\r\n                            locked: prev.locked + curr.locked,\r\n                            staked: prev.staked + curr.staked,\r\n                            unlocked: prev.unlocked + curr.unlocked,\r\n                        }\r\n                    }, { locked: 0n, staked: 0n, unlocked: 0n })\r\n                })\r\n        } else {\r\n            return this.coinbase.getBalance()\r\n        }\r\n    }\r\n\r\n    public async getDelegatees(order?: QueryStakesOrder, leftJoin = true): Promise<Array<StakeEntry>> {\r\n        const records: Array<StakeEntry> = []\r\n        records.push(...await this.coinbase.getDelegatees(order))\r\n        await Promise.all(this._accounts.map(account => account.getDelegatees(order, leftJoin).then(entries => records.push(...entries))))\r\n        if (order) {\r\n            const reverse = order?.reverse ? (+1) : (-1)\r\n            return records.sort((a, b) => {\r\n                switch (order.by) {\r\n                    case StakesOrderBy.Coins: return ((a.value.coins < b.value.coins) ? 1 : ((a.value.coins > b.value.coins) ? -1 : 0)) * reverse;\r\n                    case StakesOrderBy.Mining: return (b.value.epochs.mining - a.value.epochs.mining) * reverse;\r\n                    case StakesOrderBy.Witnessing: return (b.value.epochs.witnessing - a.value.epochs.witnessing) * reverse;\r\n                    case StakesOrderBy.Nonce: return (b.value.nonce - a.value.nonce) * reverse;\r\n                }\r\n            })\r\n        }\r\n        return records\r\n    }\r\n\r\n    public async getUtxos(reload?: boolean): Promise<Array<Utxo>> {\r\n        return Promise\r\n            .all(this.accounts.map(account => account.getUtxos(reload)))\r\n            .then(async (utxoss: Array<Array<Utxo>>) => {\r\n                // utxoss.push(await this.coinbase.getUtxos(reload))\r\n                return utxoss.flat()\r\n            })\r\n    }\r\n\r\n    public async selectUtxos(specs?: {\r\n        value?: Coins,\r\n        reload?: boolean\r\n        strategy?: UtxoSelectionStrategy\r\n    }): Promise<Array<Utxo>> {\r\n        return this\r\n            .getUtxos(specs?.reload)\r\n            .then(utxos => utils.selectUtxos({ utxos, value: specs?.value, strategy: specs?.strategy || this.strategy }))\r\n    }\r\n\r\n    // ================================================================================================================\r\n    // --- IWallet ----------------------------------------------------------------------------------------------------\r\n\r\n    public deriveAccounts(limit: number): Array<IAccount> {\r\n        if (limit > this._accounts.length) {\r\n            const startIndex = this._accounts.length > 0 ? this.accounts[this.accounts.length - 1].index + 1 : 0\r\n            limit = limit - this._accounts.length\r\n            for (let ix = 0; ix < limit; ix ++) {\r\n                this._accounts.push(new Account(\r\n                    this.root,\r\n                    this.provider,\r\n                    startIndex + ix,\r\n                    this.strategy\r\n                ))\r\n            }\r\n        }\r\n        return this._accounts\r\n    }\r\n\r\n    public async exploreAccounts(limit = 0, gap = DEFAULT_GAP): Promise<Array<IAccount>> {\r\n        if (limit === 0 || limit > this.accounts.length) {\r\n            const lastIndex = (x: Array<IAccount>) => x.length > 0 ? x[x.length - 1].index + 1 : 0\r\n            const startIndex = lastIndex(this.accounts)\r\n            for (let index = startIndex; index < lastIndex(this.accounts) + gap; index ++) {\r\n                const account = new Account(this.root, this.provider, index, this.strategy)\r\n                if (utils.totalCoins(await account.getBalance()).pedros > 0n) {\r\n                    this.accounts.push(account)\r\n                    if (limit && this.accounts.length >= limit) break;\r\n                }\r\n            }\r\n        }\r\n        return this._accounts\r\n    }\r\n\r\n    public getAccount(pkh: PublicKeyHashString, gap?: number): IAccount | undefined {\r\n        let account = this._accounts.find(account => account.internal.pkh === pkh || account.pkh === pkh)\r\n        if (!account) {\r\n            for (let index = 0; index < (gap || DEFAULT_GAP); index ++) {\r\n                account = new Account(this.root, this.provider, index, this.strategy)\r\n                if (account.pkh === pkh || account.internal.pkh === pkh) {\r\n                    this._accounts.push(account)\r\n                    return account\r\n                }\r\n            }\r\n            return undefined\r\n        } else {\r\n            return account\r\n        }\r\n    }\r\n\r\n    public getSigner(pkh?: PublicKeyHashString, gap?: number): ISigner | undefined {\r\n        if (!pkh) return this.accounts[0]?.getSigner() || this.coinbase.getSigner(pkh);\r\n        const account = this.getAccount(pkh, gap)\r\n        return account?.getSigner(pkh) || this.coinbase.getSigner(pkh)\r\n    }\r\n}\r\n"]}

package/dist/src/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./crypto";
+export * as Radon from "./radon";
+export * from "./rpc";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,cAAc,OAAO,CAAA;AACrB,cAAc,SAAS,CAAA"}