lunesjs 1.5.10 → 1.5.11

package/lib/client/wallet/service.account.d.ts

@@ -0,0 +1,20 @@
+import { IAccount } from "./wallet.types";
+declare class Account implements IAccount {
+    privateKey: string;
+    publicKey: string;
+    address: string;
+    chain: number;
+    nonce: number;
+    seed: string;
+    constructor(wallet: IAccount);
+}
+export declare function accountFactory({ privateKey, publicKey, address, nWords, chain, nonce, seed }?: {
+    privateKey?: string;
+    publicKey?: string;
+    address?: string;
+    nWords?: number;
+    chain?: number;
+    nonce?: number;
+    seed?: string;
+}): Account;
+export {};

package/lib/client/wallet/service.account.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountFactory = void 0;
+const crypto_1 = __importDefault(require("../../utils/crypto"));
+class Account {
+    constructor(wallet) {
+        this.privateKey = wallet.privateKey;
+        this.publicKey = wallet.publicKey;
+        this.address = wallet.address;
+        this.chain = wallet.chain;
+        this.nonce = wallet.nonce;
+        this.seed = wallet.seed;
+    }
+}
+function accountFactory({ privateKey, publicKey, address, nWords, chain, nonce, seed } = {}) {
+    if (seed != undefined) {
+        return new Account(Object.assign({}, crypto_1.default.fromExistingSeed(seed, nonce != undefined ? nonce : 0, chain != undefined ? chain : 1)));
+    }
+    else if (privateKey != undefined) {
+        return new Account(Object.assign({}, crypto_1.default.fromPrivateKey(privateKey, chain != undefined ? chain : 1)));
+    }
+    else if (publicKey != undefined) {
+        return new Account(Object.assign({}, crypto_1.default.fromPublicKey(publicKey, chain != undefined ? chain : 1)));
+    }
+    else if (address != undefined) {
+        return new Account(Object.assign({}, crypto_1.default.fromAddress(address, chain != undefined ? chain : 0)));
+    }
+    else {
+        return new Account(Object.assign({}, crypto_1.default.fromNewSeed(nWords != undefined ? nWords : 12, nonce != undefined ? nonce : 0, chain != undefined ? chain : 1)));
+    }
+}
+exports.accountFactory = accountFactory;

package/lib/client/wallet/wallet.types.d.ts

@@ -0,0 +1,21 @@
+export declare type empty = "";
+export declare type zero = 0;
+export declare namespace WalletTypes {
+    type Seed = string | empty;
+    type Nonce = number | zero;
+    enum Chain {
+        Mainnet = 1,
+        Testnet = 0
+    }
+    type PrivateKey = string | empty;
+    type PublicKey = string | empty;
+    type Address = string | empty;
+}
+export interface IAccount {
+    privateKey: WalletTypes.PrivateKey;
+    publicKey: WalletTypes.PublicKey;
+    address: WalletTypes.Address;
+    nonce: WalletTypes.Nonce;
+    chain: WalletTypes.Chain;
+    seed: WalletTypes.Seed;
+}

package/lib/client/wallet/wallet.types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletTypes = void 0;
+var WalletTypes;
+(function (WalletTypes) {
+    let Chain;
+    (function (Chain) {
+        Chain[Chain["Mainnet"] = 1] = "Mainnet";
+        Chain[Chain["Testnet"] = 0] = "Testnet";
+    })(Chain = WalletTypes.Chain || (WalletTypes.Chain = {}));
+})(WalletTypes = exports.WalletTypes || (exports.WalletTypes = {}));

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { transferTokenFactory } from "./client/transactions/transfer/service.transfer";
+export { accountFactory } from "./client/wallet/service.account";
+export { IAccount } from "./client/wallet/wallet.types";
+import cryptoUtils from "./utils/crypto";
+export default cryptoUtils;

package/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountFactory = exports.transferTokenFactory = void 0;
+var service_transfer_1 = require("./client/transactions/transfer/service.transfer");
+Object.defineProperty(exports, "transferTokenFactory", { enumerable: true, get: function () { return service_transfer_1.transferTokenFactory; } });
+var service_account_1 = require("./client/wallet/service.account");
+Object.defineProperty(exports, "accountFactory", { enumerable: true, get: function () { return service_account_1.accountFactory; } });
+const crypto_1 = __importDefault(require("./utils/crypto"));
+exports.default = crypto_1.default;

package/lib/utils/crypto.d.ts

@@ -0,0 +1,13 @@
+import { IAccount, WalletTypes } from "../client/wallet/wallet.types";
+declare const cryptoUtils: {
+    fromExistingSeed: (seed: string, nonce: number, chain: WalletTypes.Chain) => IAccount;
+    fromPrivateKey: (privateKey: string, chain: WalletTypes.Chain) => IAccount;
+    fromPublicKey: (publicKey: string, chain: WalletTypes.Chain) => IAccount;
+    fromAddress: (address: string, chain: WalletTypes.Chain) => IAccount;
+    fromNewSeed: (nWords: number, nonce: number, chain: WalletTypes.Chain) => IAccount;
+    validateAddress: (address: string, chain: WalletTypes.Chain) => boolean;
+    validateSignature: (publicKey: string, message: string, signature: string) => boolean;
+    fastSignature: (privateKey: string, message: string) => string;
+    fullSignature: (privateKey: string, message: string) => string;
+};
+export default cryptoUtils;

package/lib/utils/crypto.js

@@ -0,0 +1,102 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = __importDefault(require("../client/wallet/constants"));
+const wasm = __importStar(require("lunesrs"));
+const cryptoUtils = {
+    fromExistingSeed: (seed, nonce, chain) => {
+        const hidden_seed = wasm.hiddenSeed(nonce, seed);
+        const privateKey = wasm.toPrivateKey(hidden_seed);
+        const publicKey = wasm.toPublicKey(privateKey);
+        const address = wasm.toAddress(1, chain, publicKey);
+        return {
+            nonce: nonce,
+            chain: chain,
+            seed: seed,
+            privateKey: wasm.arrayToBase58(privateKey),
+            publicKey: wasm.arrayToBase58(publicKey),
+            address: wasm.arrayToBase58(address)
+        };
+    },
+    fromPrivateKey: (privateKey, chain) => {
+        const publicKey = wasm.toPublicKey(wasm.base58ToArray(privateKey));
+        const address = wasm.toAddress(1, chain, publicKey);
+        return {
+            seed: "",
+            nonce: 0,
+            chain: chain,
+            privateKey: privateKey,
+            publicKey: wasm.arrayToBase58(publicKey),
+            address: wasm.arrayToBase58(address)
+        };
+    },
+    fromPublicKey: (publicKey, chain) => {
+        const address = wasm.toAddress(1, chain, wasm.base58ToArray(publicKey));
+        return {
+            seed: "",
+            nonce: 0,
+            privateKey: "",
+            chain: chain,
+            publicKey: publicKey,
+            address: wasm.arrayToBase58(address)
+        };
+    },
+    fromAddress: (address, chain) => {
+        return {
+            seed: "",
+            nonce: 0,
+            privateKey: "",
+            publicKey: "",
+            chain: chain,
+            address: address
+        };
+    },
+    fromNewSeed: (nWords, nonce, chain) => {
+        let seed = [];
+        nWords = nWords != undefined ? Math.round(nWords / 3) : 4;
+        for (let i = 0; i < nWords; i++) {
+            for (let n in wasm.randomTripleNumber()) {
+                seed.push(constants_1.default.wordsList[n]);
+            }
+        }
+        return cryptoUtils.fromExistingSeed(seed.join(" "), nonce, chain);
+    },
+    validateAddress: (address, chain) => {
+        return wasm.validateAddress(chain, wasm.base58ToArray(address));
+    },
+    validateSignature: (publicKey, message, signature) => {
+        return wasm.validateSignature(wasm.base58ToArray(publicKey), wasm.base58ToArray(message), wasm.base58ToArray(signature));
+    },
+    fastSignature: (privateKey, message) => {
+        return wasm.arrayToBase58(wasm.fastSignature(wasm.base58ToArray(privateKey), wasm.base58ToArray(message)));
+    },
+    fullSignature: (privateKey, message) => {
+        return wasm.arrayToBase58(wasm.fullSignature(wasm.base58ToArray(privateKey), wasm.base58ToArray(message)));
+    }
+};
+exports.default = cryptoUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lunesjs",
-    "version": "1.5.10",
+    "version": "1.5.11",
     "description": "Library for communication with nodes in mainnet or testnet of the lunes-blockchain network",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",