lunesjs 1.7.0 → 1.8.0

package/lib/index.d.ts

@@ -1,7 +1,11 @@
-import { transferTokenFactory } from "./tx/transfer/service.transfer";
+import { transferTokenFactory } from "./tx/transfer/transfer.service";
+import { withdrawStakeFactory } from "./tx/stake/withdrawStake.service";
+import { createStakeFactory } from "./tx/stake/createStake.service";
 import { walletFactory } from "./wallet/wallet.service";
 declare const _default: {
     transferTokenFactory: typeof transferTokenFactory;
+    withdrawStakeFactory: typeof withdrawStakeFactory;
+    createStakeFactory: typeof createStakeFactory;
     walletFactory: typeof walletFactory;
     crypto: {
         fromSeed: (seed: string, nonce: number, chain: number) => import("./wallet/wallet.service").Wallet;

package/lib/index.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const service_transfer_1 = require("./tx/transfer/service.transfer");
+const transfer_service_1 = require("./tx/transfer/transfer.service");
+const withdrawStake_service_1 = require("./tx/stake/withdrawStake.service");
+const createStake_service_1 = require("./tx/stake/createStake.service");
 const wallet_service_1 = require("./wallet/wallet.service");
 const crypto_1 = require("./utils/crypto");
 exports.default = {
-    transferTokenFactory: service_transfer_1.transferTokenFactory,
+    transferTokenFactory: transfer_service_1.transferTokenFactory,
+    withdrawStakeFactory: withdrawStake_service_1.withdrawStakeFactory,
+    createStakeFactory: createStake_service_1.createStakeFactory,
     walletFactory: wallet_service_1.walletFactory,
     crypto: crypto_1.crypto
 };

package/lib/tx/stake/createStake.service.d.ts

@@ -0,0 +1,34 @@
+export declare class Stake {
+    senderPublicKey: string;
+    timestamp: number;
+    signature: string;
+    recipient: string;
+    message: string;
+    amount: number;
+    type: number;
+    fee: number;
+    constructor(senderPublicKey: string, timestamp: number, receiver: string, amount: number, fee: number);
+    transaction(): {
+        senderPublicKey: string;
+        timestamp: number;
+        signature: string;
+        recipient: string;
+        amount: number;
+        type: number;
+        fee: number;
+    };
+    sign(privateKey: string): Stake;
+    broadcast(node?: string): Promise<{
+        isSuccess: boolean;
+        response: object;
+    }>;
+}
+export declare type createStake = {
+    senderPublicKey: string;
+    receiverAddress: string;
+    timestamp?: number;
+    chain?: number;
+    amount: number;
+    fee?: number;
+};
+export declare function createStakeFactory(tx: createStake): Stake;

package/lib/tx/stake/createStake.service.js

@@ -0,0 +1,97 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStakeFactory = exports.Stake = void 0;
+const wasm = __importStar(require("lunesrs"));
+const utils_1 = require("./utils");
+const crypto_1 = require("../../utils/crypto");
+const signer_1 = __importDefault(require("../../utils/signer"));
+const broadcast_1 = __importDefault(require("../../utils/broadcast"));
+class Stake {
+    constructor(senderPublicKey, timestamp, receiver, amount, fee) {
+        this.senderPublicKey = senderPublicKey;
+        this.timestamp = timestamp;
+        this.signature = "";
+        this.recipient = receiver;
+        this.message = "";
+        this.amount = amount;
+        this.type = 8;
+        this.fee = fee;
+    }
+    transaction() {
+        return {
+            senderPublicKey: this.senderPublicKey,
+            timestamp: this.timestamp,
+            signature: this.signature,
+            recipient: this.recipient,
+            amount: this.amount,
+            type: this.type,
+            fee: this.fee
+        };
+    }
+    sign(privateKey) {
+        ;
+        [this.signature, this.message] = (0, signer_1.default)(privateKey, utils_1.serializeStake, this);
+        return this;
+    }
+    broadcast(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, broadcast_1.default)(node != undefined ? node : "https://lunesnode.lunes.io", this.transaction());
+        });
+    }
+}
+exports.Stake = Stake;
+function createStakeFactory(tx) {
+    const timestamp = tx.timestamp != undefined ? tx.timestamp : Date.now();
+    const fee = tx.fee != undefined ? tx.fee : 100000;
+    const chain = tx.chain != undefined ? tx.chain : 1;
+    const sender = wasm.arrayToBase58(wasm.toAddress(1, chain, wasm.base58ToArray(tx.senderPublicKey)));
+    if (timestamp < 1483228800) {
+        throw new Error(`Timestamp should be greater than 1483228800, but ${timestamp}`);
+    }
+    if (tx.amount <= 0) {
+        throw new Error(`Amount should be greater than 0, but ${tx.amount}`);
+    }
+    if (fee < 100000) {
+        throw new Error(`Fee should be greater than 100000, but ${fee}`);
+    }
+    if (crypto_1.crypto.sameChainAddress(tx.receiverAddress, sender) != true) {
+        throw new Error("Sender AND Receiver should be same chain");
+    }
+    return new Stake(tx.senderPublicKey, timestamp, tx.receiverAddress, Math.floor(tx.amount * 10e7), fee);
+}
+exports.createStakeFactory = createStakeFactory;

package/lib/tx/stake/utils.d.ts

@@ -0,0 +1,4 @@
+import { Stake } from "./createStake.service";
+import { WithdrawStake } from "./withdrawStake.service";
+export declare function serializeStake(tx: Stake): Uint8Array;
+export declare function serializeWithoutStake(tx: WithdrawStake): Uint8Array;

package/lib/tx/stake/utils.js

@@ -0,0 +1,48 @@
+"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.serializeWithoutStake = exports.serializeStake = void 0;
+const wasm = __importStar(require("lunesrs"));
+function serializeStake(tx) {
+    return new Uint8Array([
+        ...[tx.type],
+        ...wasm.base58ToArray(tx.senderPublicKey),
+        ...wasm.base58ToArray(tx.recipient),
+        ...wasm.serializeUInteger(BigInt(tx.amount)),
+        ...wasm.serializeUInteger(BigInt(tx.fee)),
+        ...wasm.serializeUInteger(BigInt(tx.timestamp))
+    ]);
+}
+exports.serializeStake = serializeStake;
+function serializeWithoutStake(tx) {
+    return new Uint8Array([
+        ...[tx.type],
+        ...wasm.base58ToArray(tx.senderPublicKey),
+        ...wasm.serializeUInteger(BigInt(tx.fee)),
+        ...wasm.serializeUInteger(BigInt(tx.timestamp)),
+        ...wasm.base58ToArray(tx.id)
+    ]);
+}
+exports.serializeWithoutStake = serializeWithoutStake;

package/lib/tx/stake/withdrawStake.service.d.ts

@@ -0,0 +1,30 @@
+export declare class WithdrawStake {
+    senderPublicKey: string;
+    timestamp: number;
+    signature: string;
+    id: string;
+    message: string;
+    type: number;
+    fee: number;
+    constructor(senderPublicKey: string, timestamp: number, id: string, fee: number);
+    transaction(): {
+        senderPublicKey: string;
+        timestamp: number;
+        signature: string;
+        id: string;
+        type: number;
+        fee: number;
+    };
+    sign(privateKey: string): WithdrawStake;
+    broadcast(node?: string): Promise<{
+        isSuccess: boolean;
+        response: object;
+    }>;
+}
+export declare type withdrawStake = {
+    senderPublicKey: string;
+    timestamp?: number;
+    id: string;
+    fee?: number;
+};
+export declare function withdrawStakeFactory(tx: withdrawStake): WithdrawStake;

package/lib/tx/stake/withdrawStake.service.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawStakeFactory = exports.WithdrawStake = void 0;
+const broadcast_1 = __importDefault(require("../../utils/broadcast"));
+const signer_1 = __importDefault(require("../../utils/signer"));
+const utils_1 = require("./utils");
+class WithdrawStake {
+    constructor(senderPublicKey, timestamp, id, fee) {
+        this.senderPublicKey = senderPublicKey;
+        this.timestamp = timestamp;
+        this.signature = "";
+        this.id = id;
+        this.message = "";
+        this.type = 9;
+        this.fee = fee;
+    }
+    transaction() {
+        return {
+            senderPublicKey: this.senderPublicKey,
+            timestamp: this.timestamp,
+            signature: this.signature,
+            id: this.id,
+            type: this.type,
+            fee: this.fee
+        };
+    }
+    sign(privateKey) {
+        ;
+        [this.signature, this.message] = (0, signer_1.default)(privateKey, utils_1.serializeWithoutStake, this);
+        return this;
+    }
+    broadcast(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, broadcast_1.default)(node != undefined ? node : "https://lunesnode.lunes.io", this.transaction());
+        });
+    }
+}
+exports.WithdrawStake = WithdrawStake;
+function withdrawStakeFactory(tx) {
+    const timestamp = tx.timestamp != undefined ? tx.timestamp : Date.now();
+    const fee = tx.fee != undefined ? tx.fee : 100000;
+    if (timestamp < 1483228800) {
+        throw new Error(`Timestamp should be greater than 1483228800, but ${timestamp}`);
+    }
+    if (fee < 100000) {
+        throw new Error(`Fee should be greater than 100000, but ${fee}`);
+    }
+    return new WithdrawStake(tx.senderPublicKey, timestamp, tx.id, fee);
+}
+exports.withdrawStakeFactory = withdrawStakeFactory;

package/lib/tx/transfer/{service.transfer.d.ts → transfer.service.d.ts}

@@ -20,17 +20,21 @@ export declare class TransferToken {
         assetId: string;
         amount: number;
         sender: string;
+        type: number;
         fee: number;
     };
     sign(privateKey: string): TransferToken;
+    broadcast(node?: string): Promise<{
+        isSuccess: boolean;
+        response: object;
+    }>;
 }
 export declare type Transfer = {
     senderPublicKey: string;
+    receiverAddress: string;
     timestamp?: number;
     feeAsset?: string;
-    receiver: string;
     assetId?: string;
-    sender?: string;
     chain?: number;
     amount: number;
     fee?: number;

package/lib/tx/transfer/{service.transfer.js → transfer.service.js}

@@ -22,11 +22,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transferTokenFactory = exports.TransferToken = void 0;
-const crypto_1 = require("../../utils/crypto");
 const utils_1 = require("./utils");
+const crypto_1 = require("../../utils/crypto");
 const wasm = __importStar(require("lunesrs"));
+const signer_1 = __importDefault(require("../../utils/signer"));
+const broadcast_1 = __importDefault(require("../../utils/broadcast"));
 class TransferToken {
     constructor(senderPublicKey, timestamp, receiver, feeAsset, assetId, amount, sender, fee) {
         this.senderPublicKey = senderPublicKey;
@@ -51,13 +65,20 @@ class TransferToken {
             assetId: this.assetId,
             amount: this.amount,
             sender: this.sender,
+            type: this.type,
             fee: this.fee
         };
     }
     sign(privateKey) {
-        this.signature = (0, utils_1.signTransfer)(privateKey, this);
+        ;
+        [this.signature, this.message] = (0, signer_1.default)(privateKey, utils_1.serializeTransfer, this);
         return this;
     }
+    broadcast(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, broadcast_1.default)(node != undefined ? node : "https://lunesnode.lunes.io", this.transaction());
+        });
+    }
 }
 exports.TransferToken = TransferToken;
 function transferTokenFactory(tx) {
@@ -76,9 +97,9 @@ function transferTokenFactory(tx) {
     if (fee < 100000) {
         throw new Error(`Fee should be greater than 100000, but ${fee}`);
     }
-    if (crypto_1.crypto.sameChainAddress(tx.receiver, sender) != true) {
+    if (crypto_1.crypto.sameChainAddress(tx.receiverAddress, sender) != true) {
         throw new Error("Sender AND Receiver should be same chain");
     }
-    return new TransferToken(tx.senderPublicKey, timestamp, tx.receiver, feeAsset, assetId, Math.floor(tx.amount * 10e7), sender, fee);
+    return new TransferToken(tx.senderPublicKey, timestamp, tx.receiverAddress, feeAsset, assetId, Math.floor(tx.amount * 10e7), sender, fee);
 }
 exports.transferTokenFactory = transferTokenFactory;

package/lib/tx/transfer/utils.d.ts

@@ -1,3 +1,2 @@
-import { TransferToken } from "./service.transfer";
+import { TransferToken } from "./transfer.service";
 export declare function serializeTransfer(tx: TransferToken): Uint8Array;
-export declare function signTransfer(senderPrivateKey: string, tx: TransferToken): string;

package/lib/tx/transfer/utils.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signTransfer = exports.serializeTransfer = void 0;
+exports.serializeTransfer = void 0;
 const wasm = __importStar(require("lunesrs"));
 function serializeTransfer(tx) {
     const tokenId = tx.assetId != ""
@@ -44,8 +44,3 @@ function serializeTransfer(tx) {
     ]);
 }
 exports.serializeTransfer = serializeTransfer;
-function signTransfer(senderPrivateKey, tx) {
-    tx.message = wasm.arrayToBase58(serializeTransfer(tx));
-    return wasm.arrayToBase58(wasm.fastSignature(wasm.base58ToArray(senderPrivateKey), wasm.base58ToArray(tx.message)));
-}
-exports.signTransfer = signTransfer;

package/lib/utils/broadcast.d.ts

@@ -0,0 +1,6 @@
+declare type Lunes = {
+    isSuccess: boolean;
+    response: object;
+};
+export default function broadcast<T>(node: string, tx: T): Promise<Lunes>;
+export {};

package/lib/utils/broadcast.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+function broadcast(node, tx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            axios_1.default
+                .post(`${node}/transactions/broadcast`, tx)
+                .then((res) => {
+                resolve({
+                    isSuccess: true,
+                    response: Object.assign({}, res.data)
+                });
+            })
+                .catch((erro) => {
+                resolve({
+                    isSuccess: false,
+                    response: {
+                        codeError: erro.response.data.error,
+                        message: erro.response.data.message
+                    }
+                });
+            });
+        }));
+    });
+}
+exports.default = broadcast;

package/lib/utils/signer.d.ts

@@ -0,0 +1 @@
+export default function signer<T>(senderPrivateKey: string, serializer: (tx: T) => Uint8Array, tx: T): [string, string];

package/lib/utils/signer.js

@@ -0,0 +1,34 @@
+"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 });
+const wasm = __importStar(require("lunesrs"));
+function signer(senderPrivateKey, serializer, tx) {
+    const message = wasm.arrayToBase58(serializer(tx));
+    return [
+        wasm.arrayToBase58(wasm.fastSignature(wasm.base58ToArray(senderPrivateKey), wasm.base58ToArray(message))),
+        message
+    ];
+}
+exports.default = signer;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lunesjs",
-    "version": "1.7.0",
+    "version": "1.8.0",
     "description": "Library for communication with nodes in mainnet or testnet of the lunes-blockchain network",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -35,6 +35,6 @@
     },
     "dependencies": {
         "axios": "^0.26.1",
-        "lunesrs": "^1.9.1"
+        "lunesrs": "^1.9.4"
     }
 }