lunesjs 1.5.0 → 1.5.4

package/dist/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/dist/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 : 0)));
+    }
+    else if (privateKey != undefined) {
+        return new Account(Object.assign({}, crypto_1.default.fromPrivateKey(privateKey, chain != undefined ? chain : 0)));
+    }
+    else if (publicKey != undefined) {
+        return new Account(Object.assign({}, crypto_1.default.fromPublicKey(publicKey, chain != undefined ? chain : 0)));
+    }
+    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/dist/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/dist/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/dist/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/dist/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,8 +1,9 @@
 {
     "name": "lunesjs",
-    "version": "1.5.0",
+    "version": "1.5.4",
     "description": "Library for communication with nodes in mainnet or testnet of the lunes-blockchain network",
-    "main": "index.js",
+    "main": "dist/*.js",
+    "types": "dist/*.d.ts",
     "repository": "git@git.lunes.io:blockchain/labs/lunesjs.git",
     "keywords": [
         "blockchain",
@@ -12,57 +13,21 @@
     "author": "lunes-platform",
     "license": "SEE LICENSE IN ./LICENSE",
     "scripts": {
-        "autotest": "yarn jest --watchAll",
-        "postinstall": "husky install",
+        "build": "tsc --declaration",
+        "fmtc": "prettier -c",
         "fmt": "prettier -w .",
-        "test": "yarn jest",
-        "build": "tsc",
-        "commit": "cz"
+        "test": "yarn jest"
     },
     "devDependencies": {
-        "@commitlint/config-conventional": "^16.0.0",
-        "cz-conventional-changelog": "^3.3.0",
-        "@commitlint/cli": "^16.1.0",
         "@types/jest": "^27.0.3",
+        "jest": "^27.4.5",
         "jest-junit": "^13.0.0",
-        "typescript": "^4.5.4",
+        "prettier": "2.6.2",
         "ts-jest": "^27.1.2",
-        "prettier": "2.6.1",
-        "husky": "^7.0.4",
-        "jest": "^27.4.5"
+        "typescript": "^4.5.4"
     },
     "dependencies": {
         "axios": "^0.26.1",
-        "lunesrs": "1.7.0"
-    },
-    "lint-staged": {
-        "**/*": "prettier --write"
-    },
-    "config": {
-        "commitizen": {
-            "path": "./node_modules/cz-conventional-changelog",
-            "types": {
-                "added": {
-                    "description": "Add a new feature",
-                    "title": "Added"
-                },
-                "merged": {
-                    "description": "Resolves an issue and merge it to prod",
-                    "title": "Merged"
-                },
-                "fixed": {
-                    "description": "Fix a bug",
-                    "title": "Fixed"
-                },
-                "refactored": {
-                    "description": "Does not add a feature or fix a bug",
-                    "title": "Refactored"
-                },
-                "deprecated": {
-                    "description": "Breaks compatibility with an earlier version",
-                    "title": "Deprecated"
-                }
-            }
-        }
+        "lunesrs": "1.8.1"
     }
 }

package/src/client/transactions/transfer/service.transfer.ts

@@ -7,10 +7,8 @@ import * as wasm from "lunesrs"
 
 class TransferToken implements BaseTransaction {
     private tx: ITransfer
-    private chain: WalletTypes.Chain
-    constructor(tx: ITransfer, chain: WalletTypes.Chain) {
+    constructor(tx: ITransfer) {
         this.tx = tx
-        this.chain = chain
     }
 
     transaction(): ITransfer {
@@ -43,22 +41,18 @@ export function transferTokenFactory(
     ) {
         throw new Error("dados invalidos")
     }
-    return new TransferToken(
-        {
-            senderPublicKey: senderPublicKey,
-            recipient: recipient,
-            amount: amount,
-            sender: wasm.hexToB58(
-                wasm.toAddressHex(1, chain_id, wasm.b58ToVec(senderPublicKey))
-            ),
-            timestamp:
-                timestamp != undefined ? timestamp : new Date().getTime(),
-            feeAsset: feeAsset != undefined ? feeAsset : "",
-            assetId: assetId != undefined ? assetId : "",
-            type: TransactionsTypes.TransferToken.int,
-            fee: fee != undefined ? fee : TransactionsTypes.TransferToken.fee,
-            signature: ""
-        },
-        chain_id
-    )
+    return new TransferToken({
+        senderPublicKey: senderPublicKey,
+        recipient: recipient,
+        amount: amount,
+        sender: wasm.arrayToBase58(
+            wasm.toAddress(1, chain_id, wasm.base58ToArray(senderPublicKey))
+        ),
+        timestamp: timestamp != undefined ? timestamp : new Date().getTime(),
+        feeAsset: feeAsset != undefined ? feeAsset : "",
+        assetId: assetId != undefined ? assetId : "",
+        type: TransactionsTypes.TransferToken.int,
+        fee: fee != undefined ? fee : TransactionsTypes.TransferToken.fee,
+        signature: ""
+    })
 }

package/src/client/transactions/transfer/validator.ts

@@ -14,19 +14,26 @@ const validator = {
         amount: number,
         fee: number,
         recipient: string
-    ): Array<number> => {
-        const tokenId = assetId != "" ? [1, ...wasm.b58ToVec(assetId)] : [0]
-        const tokenFee = feeAsset != "" ? [1, ...wasm.b58ToVec(feeAsset)] : [0]
-        return [
+    ) => {
+        const tokenId: Uint8Array =
+            assetId != ""
+                ? new Uint8Array([1, ...wasm.base58ToArray(assetId)])
+                : new Uint8Array([0])
+        const tokenFee: Uint8Array =
+            feeAsset != ""
+                ? new Uint8Array([1, ...wasm.base58ToArray(feeAsset)])
+                : new Uint8Array([0])
+
+        return new Uint8Array([
             ...[TransactionsTypes.TransferToken.int],
-            ...wasm.b58ToVec(senderPublicKey),
+            ...wasm.base58ToArray(senderPublicKey),
             ...tokenId,
             ...tokenFee,
             ...wasm.serializeUInteger(BigInt(timestamp)),
             ...wasm.serializeUInteger(BigInt(amount)),
             ...wasm.serializeUInteger(BigInt(fee)),
-            ...wasm.b58ToVec(recipient)
-        ]
+            ...wasm.base58ToArray(recipient)
+        ])
     },
     ready: (
         senderPublicKey: string,
@@ -34,8 +41,8 @@ const validator = {
         amount: number,
         chain: WalletTypes.Chain
     ): boolean => {
-        const sender = wasm.hexToB58(
-            wasm.toAddressHex(1, chain, wasm.b58ToVec(senderPublicKey))
+        const sender = wasm.arrayToBase58(
+            wasm.toAddress(1, chain, wasm.base58ToArray(senderPublicKey))
         )
         if (amount <= 0) {
             return false
@@ -60,9 +67,10 @@ const validator = {
             tx.fee,
             tx.recipient
         )
+
         return cryptoUtils.fastSignature(
             privateKey,
-            wasm.vecToB58(new Uint8Array(message))
+            wasm.arrayToBase58(new Uint8Array(message))
         )
     },
     send: async (tx: ITransfer) => {

package/src/client/wallet/service.account.ts

@@ -1,4 +1,4 @@
-import { IAccount, WalletTypes } from "./wallet.types"
+import { IAccount } from "./wallet.types"
 import cryptoUtils from "../../utils/crypto"
 
 class Account implements IAccount {

package/src/utils/crypto.ts

@@ -9,37 +9,37 @@ const cryptoUtils = {
         chain: WalletTypes.Chain
     ): IAccount => {
         const hidden_seed = wasm.hiddenSeed(nonce, seed)
-        const privateKey = wasm.toPrivateKeyHex(wasm.fromStrHex(hidden_seed))
-        const publicKey = wasm.toPublicKeyHex(wasm.fromStrHex(privateKey))
-        const address = wasm.toAddressHex(1, chain, wasm.fromStrHex(publicKey))
+        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.hexToB58(privateKey),
-            publicKey: wasm.hexToB58(publicKey),
-            address: wasm.hexToB58(address)
+            privateKey: wasm.arrayToBase58(privateKey),
+            publicKey: wasm.arrayToBase58(publicKey),
+            address: wasm.arrayToBase58(address)
         }
     },
     fromPrivateKey: (
         privateKey: string,
         chain: WalletTypes.Chain
     ): IAccount => {
-        const publicKey = wasm.toPublicKeyHex(wasm.b58ToVec(privateKey))
-        const address = wasm.toAddressHex(1, chain, wasm.fromStrHex(publicKey))
+        const publicKey = wasm.toPublicKey(wasm.base58ToArray(privateKey))
+        const address = wasm.toAddress(1, chain, publicKey)
 
         return {
             seed: "",
             nonce: 0,
             chain: chain,
             privateKey: privateKey,
-            publicKey: wasm.hexToB58(publicKey),
-            address: wasm.hexToB58(address)
+            publicKey: wasm.arrayToBase58(publicKey),
+            address: wasm.arrayToBase58(address)
         }
     },
     fromPublicKey: (publicKey: string, chain: WalletTypes.Chain): IAccount => {
-        const address = wasm.toAddressHex(1, chain, wasm.b58ToVec(publicKey))
+        const address = wasm.toAddress(1, chain, wasm.base58ToArray(publicKey))
 
         return {
             seed: "",
@@ -47,7 +47,7 @@ const cryptoUtils = {
             privateKey: "",
             chain: chain,
             publicKey: publicKey,
-            address: wasm.hexToB58(address)
+            address: wasm.arrayToBase58(address)
         }
     },
     fromAddress: (address: string, chain: WalletTypes.Chain): IAccount => {
@@ -75,7 +75,7 @@ const cryptoUtils = {
         return cryptoUtils.fromExistingSeed(seed.join(" "), nonce, chain)
     },
     validateAddress: (address: string, chain: WalletTypes.Chain): boolean => {
-        return wasm.validateAddress(chain, wasm.b58ToVec(address))
+        return wasm.validateAddress(chain, wasm.base58ToArray(address))
     },
     validateSignature: (
         publicKey: string,
@@ -83,28 +83,24 @@ const cryptoUtils = {
         signature: string
     ): boolean => {
         return wasm.validateSignature(
-            wasm.toVecu32(wasm.b58ToVec(publicKey)),
-            wasm.toVecu32(wasm.b58ToVec(message)),
-            wasm.toVecu32(wasm.b58ToVec(signature))
+            wasm.base58ToArray(publicKey),
+            wasm.base58ToArray(message),
+            wasm.base58ToArray(signature)
         )
     },
     fastSignature: (privateKey: string, message: string) => {
-        return wasm.hexToB58(
-            wasm.vecu32ToHex(
-                wasm.fastSignature(
-                    wasm.toVecu32(wasm.b58ToVec(privateKey)),
-                    wasm.toVecu32(wasm.b58ToVec(message))
-                )
+        return wasm.arrayToBase58(
+            wasm.fastSignature(
+                wasm.base58ToArray(privateKey),
+                wasm.base58ToArray(message)
             )
         )
     },
     fullSignature: (privateKey: string, message: string) => {
-        return wasm.hexToB58(
-            wasm.vecu32ToHex(
-                wasm.fullSignature(
-                    wasm.toVecu32(wasm.b58ToVec(privateKey)),
-                    wasm.toVecu32(wasm.b58ToVec(message))
-                )
+        return wasm.arrayToBase58(
+            wasm.fullSignature(
+                wasm.base58ToArray(privateKey),
+                wasm.base58ToArray(message)
             )
         )
     }

package/test/client/transactions/transfer/transfer.token.test.ts

@@ -55,17 +55,19 @@ describe("Transfer Token Suite", () => {
     })
 
     it("Serialize Transfer Transaction ", () => {
-        expect(wasm.vecToB58(Uint8Array.from(message))).toEqual(
+        expect(wasm.arrayToBase58(Uint8Array.from(message))).toEqual(
             "2J2EfWqeqbH17PC5yfioAeQ5h27J76uduH5nafAUuJhKb8gHCSqpDFV4oGgWPwQkBgg9tfQjatWZu8eiYYe6NF67Sd5Hf7ieAsaZT5hZow9xgjefbfs5"
         )
-        expect(message).toEqual([
-            4, 28, 26, 172, 20, 253, 115, 23, 6, 248, 59, 119, 129, 151, 144, 5,
-            252, 208, 116, 12, 81, 146, 227, 208, 88, 57, 27, 134, 143, 7, 76,
-            94, 8, 0, 0, 0, 0, 1, 127, 201, 78, 107, 19, 0, 0, 0, 23, 72, 118,
-            232, 0, 0, 0, 0, 0, 0, 15, 66, 64, 1, 49, 146, 80, 170, 11, 139, 27,
-            185, 41, 131, 242, 219, 45, 180, 199, 38, 41, 173, 240, 198, 30,
-            146, 73, 23, 128
-        ])
+        expect(message).toEqual(
+            new Uint8Array([
+                4, 28, 26, 172, 20, 253, 115, 23, 6, 248, 59, 119, 129, 151,
+                144, 5, 252, 208, 116, 12, 81, 146, 227, 208, 88, 57, 27, 134,
+                143, 7, 76, 94, 8, 0, 0, 0, 0, 1, 127, 201, 78, 107, 19, 0, 0,
+                0, 23, 72, 118, 232, 0, 0, 0, 0, 0, 0, 15, 66, 64, 1, 49, 146,
+                80, 170, 11, 139, 27, 185, 41, 131, 242, 219, 45, 180, 199, 38,
+                41, 173, 240, 198, 30, 146, 73, 23, 128
+            ])
+        )
         expect(rawTx).toStrictEqual({
             senderPublicKey: "2ti1GM7F7J78J347fqSWSVocueDV3RSCFkLSKqmhk35Z",
             recipient: "37xRcbn1LiT1Az4REoLhjpca93jPG1gTEwq",
@@ -86,9 +88,9 @@ describe("Transfer Token Suite", () => {
         expect(tx.transaction().signature).not.toBe("")
 
         const result = wasm.validateSignature(
-            wasm.toVecu32(wasm.b58ToVec(senderAccount.publicKey)),
-            new Uint32Array(message),
-            wasm.toVecu32(wasm.b58ToVec(sign))
+            wasm.base58ToArray(senderAccount.publicKey),
+            new Uint8Array(message),
+            wasm.base58ToArray(sign)
         )
         expect(result).toBe(true)
     })

package/test/client/wallet/service.account.test.ts

@@ -252,16 +252,26 @@ describe("Create Signatures", () => {
         })
     }
     const message = [
-        wasm.stringToB58("Hello, Lunes Signature!"),
-        wasm.stringToB58(
-            "This is a new test for validate Signatures in Lunes Cryptography"
+        wasm.arrayToBase58(wasm.serializeString("Hello, Lunes Signature!")),
+        wasm.arrayToBase58(
+            wasm.serializeString(
+                "This is a new test for validate Signatures in Lunes Cryptography"
+            )
+        ),
+        wasm.arrayToBase58(
+            wasm.serializeString("Let's do some more tests just in case")
         ),
-        wasm.stringToB58("Let's do some more tests just in case"),
-        wasm.stringToB58("One more to see if everything is working well"),
-        wasm.stringToB58(
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. \
+        wasm.arrayToBase58(
+            wasm.serializeString(
+                "One more to see if everything is working well"
+            )
+        ),
+        wasm.arrayToBase58(
+            wasm.serializeString(
+                "Lorem ipsum dolor sit amet, consectetur adipiscing elit. \
         Maecenas turpis felis, gravida eget dapibus quis, molestie at mi. \
         Phasellus quis mollis nulla. Nam euismod nec diam in viverra."
+            )
         )
     ]