lunesjs 1.7.1 → 1.9.0

package/lib/index.d.ts

@@ -1,7 +1,19 @@
 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";
+import { issueTokenFactory } from "./tx/tokens/issueToken.service";
+import { issueNFTFactory } from "./tx/tokens/issueToken.service";
+import { reissueTokenFactory } from "./tx/tokens/reissueToken.service";
+import { burnTokenFactory } from "./tx/tokens/burnToken.service";
 declare const _default: {
     transferTokenFactory: typeof transferTokenFactory;
+    withdrawStakeFactory: typeof withdrawStakeFactory;
+    reissueTokenFactory: typeof reissueTokenFactory;
+    createStakeFactory: typeof createStakeFactory;
+    issueTokenFactory: typeof issueTokenFactory;
+    burnTokenFactory: typeof burnTokenFactory;
+    issueNFTFactory: typeof issueNFTFactory;
     walletFactory: typeof walletFactory;
     crypto: {
         fromSeed: (seed: string, nonce: number, chain: number) => import("./wallet/wallet.service").Wallet;

package/lib/index.js

@@ -1,10 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
+const issueToken_service_1 = require("./tx/tokens/issueToken.service");
+const issueToken_service_2 = require("./tx/tokens/issueToken.service");
+const reissueToken_service_1 = require("./tx/tokens/reissueToken.service");
+const burnToken_service_1 = require("./tx/tokens/burnToken.service");
 exports.default = {
     transferTokenFactory: transfer_service_1.transferTokenFactory,
+    withdrawStakeFactory: withdrawStake_service_1.withdrawStakeFactory,
+    reissueTokenFactory: reissueToken_service_1.reissueTokenFactory,
+    createStakeFactory: createStake_service_1.createStakeFactory,
+    issueTokenFactory: issueToken_service_1.issueTokenFactory,
+    burnTokenFactory: burnToken_service_1.burnTokenFactory,
+    issueNFTFactory: issueToken_service_2.issueNFTFactory,
     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,93 @@
+"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 (crypto_1.crypto.sameChainAddress(tx.receiverAddress, sender) != true)
+        throw new Error("Sender AND Receiver should be same chain");
+    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}`);
+    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,60 @@
+"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/tokens/burnToken.service.d.ts

@@ -0,0 +1,33 @@
+export declare class BurnToken {
+    senderPublicKey: string;
+    timestamp: number;
+    signature: string;
+    quantity: number;
+    assetId: string;
+    message: string;
+    type: number;
+    fee: number;
+    constructor(senderPublicKey: string, timestamp: number, quantity: number, assetId: string, fee: number);
+    transaction(): {
+        senderPublicKey: string;
+        timestamp: number;
+        signature: string;
+        quantity: number;
+        assetId: string;
+        type: number;
+        fee: number;
+    };
+    sign(privateKey: string): BurnToken;
+    broadcast(node?: string): Promise<{
+        isSuccess: boolean;
+        response: object;
+    }>;
+}
+export declare type Reissue = {
+    senderPublicKey: string;
+    timestamp?: number;
+    quantity: number;
+    tokenId: string;
+    fee?: number;
+};
+export declare function burnTokenFactory(tx: Reissue): BurnToken;

package/lib/tx/tokens/burnToken.service.js

@@ -0,0 +1,64 @@
+"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.burnTokenFactory = exports.BurnToken = void 0;
+const utils_1 = require("./utils");
+const broadcast_1 = __importDefault(require("../../utils/broadcast"));
+const signer_1 = __importDefault(require("../../utils/signer"));
+class BurnToken {
+    constructor(senderPublicKey, timestamp, quantity, assetId, fee) {
+        this.senderPublicKey = senderPublicKey;
+        this.timestamp = timestamp;
+        this.quantity = quantity;
+        this.assetId = assetId;
+        this.signature = "";
+        this.message = "";
+        this.fee = fee;
+        this.type = 5;
+    }
+    transaction() {
+        return {
+            senderPublicKey: this.senderPublicKey,
+            timestamp: this.timestamp,
+            signature: this.signature,
+            quantity: this.quantity,
+            assetId: this.assetId,
+            type: this.type,
+            fee: this.fee
+        };
+    }
+    sign(privateKey) {
+        ;
+        [this.signature, this.message] = (0, signer_1.default)(privateKey, utils_1.serializeBurnToken, 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.BurnToken = BurnToken;
+function burnTokenFactory(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 (tx.quantity <= 0)
+        throw new Error(`Amount should be greater than 0, but ${tx.quantity}`);
+    if (fee < 100000)
+        throw new Error(`Fee should be greater than 100000, but ${fee}`);
+    return new BurnToken(tx.senderPublicKey, timestamp, Math.floor(tx.quantity * 10e7), tx.tokenId, fee);
+}
+exports.burnTokenFactory = burnTokenFactory;

package/lib/tx/tokens/issueToken.service.d.ts

@@ -0,0 +1,50 @@
+export declare class Token {
+    senderPublicKey: string;
+    description: string;
+    reissuable: number;
+    timestamp: number;
+    signature: string;
+    quantity: number;
+    decimals: number;
+    message: string;
+    name: string;
+    type: number;
+    fee: number;
+    constructor(senderPublicKey: string, description: string, reissuable: number, timestamp: number, quantity: number, decimals: number, name: string, fee: number);
+    transaction(): {
+        senderPublicKey: string;
+        description: string;
+        reissuable: number;
+        timestamp: number;
+        signature: string;
+        quantity: number;
+        decimals: number;
+        name: string;
+        type: number;
+        fee: number;
+    };
+    sign(privateKey: string): Token;
+    broadcast(node?: string): Promise<{
+        isSuccess: boolean;
+        response: object;
+    }>;
+}
+export declare type _Token = {
+    senderPublicKey: string;
+    description: string;
+    reissuable?: boolean;
+    timestamp?: number;
+    quantity: number;
+    decimals?: number;
+    name: string;
+    fee?: number;
+};
+export declare function issueTokenFactory(tx: _Token): Token;
+export declare type NFT = {
+    senderPublicKey: string;
+    description: string;
+    timestamp?: number;
+    name: string;
+    fee?: number;
+};
+export declare function issueNFTFactory(tx: NFT): Token;

package/lib/tx/tokens/issueToken.service.js

@@ -0,0 +1,99 @@
+"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.issueNFTFactory = exports.issueTokenFactory = exports.Token = void 0;
+const utils_1 = require("./utils");
+const broadcast_1 = __importDefault(require("../../utils/broadcast"));
+const signer_1 = __importDefault(require("../../utils/signer"));
+class Token {
+    constructor(senderPublicKey, description, reissuable, timestamp, quantity, decimals, name, fee) {
+        this.senderPublicKey = senderPublicKey;
+        this.description = description;
+        this.reissuable = reissuable;
+        this.timestamp = timestamp;
+        this.quantity = quantity;
+        this.decimals = decimals;
+        this.signature = "";
+        this.message = "";
+        this.name = name;
+        this.fee = fee;
+        this.type = 3;
+    }
+    transaction() {
+        return {
+            senderPublicKey: this.senderPublicKey,
+            description: this.description,
+            reissuable: this.reissuable,
+            timestamp: this.timestamp,
+            signature: this.signature,
+            quantity: this.quantity,
+            decimals: this.decimals,
+            name: this.name,
+            type: this.type,
+            fee: this.fee
+        };
+    }
+    sign(privateKey) {
+        ;
+        [this.signature, this.message] = (0, signer_1.default)(privateKey, utils_1.serializeIssueToken, 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.Token = Token;
+function issueTokenFactory(tx) {
+    const timestamp = tx.timestamp != undefined ? tx.timestamp : Date.now();
+    const decimals = tx.decimals != undefined ? tx.decimals : 8;
+    const fee = tx.fee != undefined ? tx.fee : 100000;
+    const reissuable = () => {
+        if (tx.reissuable != undefined) {
+            return tx.reissuable == true ? 1 : 0;
+        }
+        else {
+            return 1;
+        }
+    };
+    if (tx.description.length > 1000)
+        throw new Error(`Description should be less than 1000, but ${tx.description.length}`);
+    if (timestamp < 1483228800)
+        throw new Error(`Timestamp should be greater than 1483228800, but ${timestamp}`);
+    if (tx.name.length > 16)
+        throw new Error(`Name should be less than 16 char, but ${tx.name.length}`);
+    if (tx.quantity <= 0)
+        throw new Error(`Amount should be greater than 0, but ${tx.quantity}`);
+    if (decimals > 8)
+        throw new Error(`Decimals should be less than 8, but ${decimals}`);
+    if (fee < 100000)
+        throw new Error(`Fee should be greater than 100000, but ${fee}`);
+    return new Token(tx.senderPublicKey, tx.description, reissuable(), timestamp, Math.floor(tx.quantity * 10e7), decimals, tx.name, fee);
+}
+exports.issueTokenFactory = issueTokenFactory;
+function issueNFTFactory(tx) {
+    const timestamp = tx.timestamp != undefined ? tx.timestamp : Date.now();
+    const fee = tx.fee != undefined ? tx.fee : 100000;
+    if (tx.description.length > 1000)
+        throw new Error(`Description should be less than 1000, but ${tx.description.length}`);
+    if (timestamp < 1483228800)
+        throw new Error(`Timestamp should be greater than 1483228800, but ${timestamp}`);
+    if (tx.name.length > 16)
+        throw new Error(`Name should be less than 16 char, but ${tx.name.length}`);
+    if (fee < 100000)
+        throw new Error(`Fee should be greater than 100000, but ${fee}`);
+    return new Token(tx.senderPublicKey, tx.description, 0, timestamp, 1, 0, tx.name, fee);
+}
+exports.issueNFTFactory = issueNFTFactory;

package/lib/tx/tokens/reissueToken.service.d.ts

@@ -0,0 +1,36 @@
+export declare class ReissueToken {
+    senderPublicKey: string;
+    reissuable: number;
+    timestamp: number;
+    signature: string;
+    quantity: number;
+    assetId: string;
+    message: string;
+    type: number;
+    fee: number;
+    constructor(senderPublicKey: string, reissuable: number, timestamp: number, quantity: number, assetId: string, fee: number);
+    transaction(): {
+        senderPublicKey: string;
+        reissuable: number;
+        timestamp: number;
+        signature: string;
+        quantity: number;
+        assetId: string;
+        type: number;
+        fee: number;
+    };
+    sign(privateKey: string): ReissueToken;
+    broadcast(node?: string): Promise<{
+        isSuccess: boolean;
+        response: object;
+    }>;
+}
+export declare type Reissue = {
+    senderPublicKey: string;
+    reissuable?: boolean;
+    timestamp?: number;
+    quantity: number;
+    tokenId: string;
+    fee?: number;
+};
+export declare function reissueTokenFactory(tx: Reissue): ReissueToken;

package/lib/tx/tokens/reissueToken.service.js

@@ -0,0 +1,76 @@
+"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.reissueTokenFactory = exports.ReissueToken = void 0;
+const utils_1 = require("./utils");
+const broadcast_1 = __importDefault(require("../../utils/broadcast"));
+const signer_1 = __importDefault(require("../../utils/signer"));
+class ReissueToken {
+    constructor(senderPublicKey, reissuable, timestamp, quantity, assetId, fee) {
+        this.senderPublicKey = senderPublicKey;
+        this.reissuable = reissuable;
+        this.timestamp = timestamp;
+        this.quantity = quantity;
+        (this.assetId = assetId), (this.signature = "");
+        this.message = "";
+        this.fee = fee;
+        this.type = 6;
+    }
+    transaction() {
+        return {
+            senderPublicKey: this.senderPublicKey,
+            reissuable: this.reissuable,
+            timestamp: this.timestamp,
+            signature: this.signature,
+            quantity: this.quantity,
+            assetId: this.assetId,
+            type: this.type,
+            fee: this.fee
+        };
+    }
+    sign(privateKey) {
+        ;
+        [this.signature, this.message] = (0, signer_1.default)(privateKey, utils_1.serializeReissueToken, 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.ReissueToken = ReissueToken;
+function reissueTokenFactory(tx) {
+    const timestamp = tx.timestamp != undefined ? tx.timestamp : Date.now();
+    const fee = tx.fee != undefined ? tx.fee : 100000;
+    const reissuable = () => {
+        if (tx.reissuable != undefined) {
+            return tx.reissuable == true ? 1 : 0;
+        }
+        else {
+            return 1;
+        }
+    };
+    if (timestamp < 1483228800) {
+        throw new Error(`Timestamp should be greater than 1483228800, but ${timestamp}`);
+    }
+    if (tx.quantity <= 0) {
+        throw new Error(`Amount should be greater than 0, but ${tx.quantity}`);
+    }
+    if (fee < 100000) {
+        throw new Error(`Fee should be greater than 100000, but ${fee}`);
+    }
+    return new ReissueToken(tx.senderPublicKey, reissuable(), timestamp, Math.floor(tx.quantity * 10e7), tx.tokenId, fee);
+}
+exports.reissueTokenFactory = reissueTokenFactory;

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

@@ -0,0 +1,6 @@
+import { Token } from "./issueToken.service";
+import { ReissueToken } from "./reissueToken.service";
+import { BurnToken } from "./burnToken.service";
+export declare function serializeIssueToken(tx: Token): Uint8Array;
+export declare function serializeReissueToken(tx: ReissueToken): Uint8Array;
+export declare function serializeBurnToken(tx: BurnToken): Uint8Array;

package/lib/tx/tokens/utils.js

@@ -0,0 +1,66 @@
+"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.serializeBurnToken = exports.serializeReissueToken = exports.serializeIssueToken = void 0;
+const wasm = __importStar(require("lunesrs"));
+function serializeIssueToken(tx) {
+    return new Uint8Array([
+        ...[tx.type],
+        ...wasm.base58ToArray(tx.senderPublicKey),
+        ...wasm.serializeUInteger(BigInt(tx.name.length)),
+        ...wasm.serializeString(tx.name),
+        ...wasm.serializeString(tx.description),
+        ...wasm.serializeString(tx.description),
+        ...wasm.serializeUInteger(BigInt(tx.quantity)),
+        ...wasm.serializeUInteger(BigInt(tx.decimals)),
+        ...[tx.reissuable],
+        ...wasm.serializeUInteger(BigInt(tx.fee)),
+        ...wasm.serializeUInteger(BigInt(tx.timestamp))
+    ]);
+}
+exports.serializeIssueToken = serializeIssueToken;
+function serializeReissueToken(tx) {
+    return new Uint8Array([
+        ...[tx.type],
+        ...wasm.base58ToArray(tx.senderPublicKey),
+        ...wasm.base58ToArray(tx.assetId),
+        ...wasm.serializeUInteger(BigInt(tx.quantity)),
+        ...wasm.serializeUInteger(BigInt(tx.reissuable)),
+        ...wasm.serializeUInteger(BigInt(tx.fee)),
+        ...wasm.serializeUInteger(BigInt(tx.timestamp))
+    ]);
+}
+exports.serializeReissueToken = serializeReissueToken;
+function serializeBurnToken(tx) {
+    return new Uint8Array([
+        ...[tx.type],
+        ...wasm.base58ToArray(tx.senderPublicKey),
+        ...wasm.base58ToArray(tx.assetId),
+        ...wasm.serializeUInteger(BigInt(tx.quantity)),
+        ...wasm.serializeUInteger(BigInt(tx.fee)),
+        ...wasm.serializeUInteger(BigInt(tx.timestamp))
+    ]);
+}
+exports.serializeBurnToken = serializeBurnToken;

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

@@ -26,25 +26,7 @@ export declare class TransferToken {
     sign(privateKey: string): TransferToken;
     broadcast(node?: string): Promise<{
         isSuccess: boolean;
-        response: {
-            senderPublicKey: string;
-            timestamp: number;
-            signature: string;
-            recipient: string;
-            feeAsset: string;
-            assetId: string;
-            sender: string;
-            amount: number;
-            type: number;
-            fee: number;
-            id: string;
-        };
-    } | {
-        isSuccess: boolean;
-        response: {
-            codeError: number;
-            message: string;
-        };
+        response: object;
     }>;
 }
 export declare type Transfer = {

package/lib/tx/transfer/transfer.service.js

@@ -31,11 +31,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 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;
@@ -65,12 +70,13 @@ class TransferToken {
         };
     }
     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, utils_1.broadcastTransfer)(node != undefined ? node : "https://lunesnode-testnet.lunes.io", this);
+            return yield (0, broadcast_1.default)(node != undefined ? node : "https://lunesnode.lunes.io", this.transaction());
         });
     }
 }
@@ -82,18 +88,14 @@ function transferTokenFactory(tx) {
     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) {
+    if (crypto_1.crypto.sameChainAddress(tx.receiverAddress, sender) != true)
+        throw new Error("Sender AND Receiver should be same chain");
+    if (timestamp < 1483228800)
         throw new Error(`Timestamp should be greater than 1483228800, but ${timestamp}`);
-    }
-    if (tx.amount <= 0) {
+    if (tx.amount <= 0)
         throw new Error(`Amount should be greater than 0, but ${tx.amount}`);
-    }
-    if (fee < 100000) {
+    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 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,28 +1,2 @@
 import { TransferToken } from "./transfer.service";
 export declare function serializeTransfer(tx: TransferToken): Uint8Array;
-export declare function signTransfer(senderPrivateKey: string, tx: TransferToken): string;
-export declare function broadcastTransfer(node: string, tx: TransferToken): Promise<TransferSuccess | TransferFail>;
-declare type TransferSuccess = {
-    isSuccess: boolean;
-    response: {
-        senderPublicKey: string;
-        timestamp: number;
-        signature: string;
-        recipient: string;
-        feeAsset: string;
-        assetId: string;
-        sender: string;
-        amount: number;
-        type: number;
-        fee: number;
-        id: string;
-    };
-};
-declare type TransferFail = {
-    isSuccess: boolean;
-    response: {
-        codeError: number;
-        message: string;
-    };
-};
-export {};

package/lib/tx/transfer/utils.js

@@ -22,22 +22,9 @@ 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.broadcastTransfer = exports.signTransfer = exports.serializeTransfer = void 0;
+exports.serializeTransfer = void 0;
 const wasm = __importStar(require("lunesrs"));
-const axios_1 = __importDefault(require("axios"));
 function serializeTransfer(tx) {
     const tokenId = tx.assetId != ""
         ? new Uint8Array([1, ...wasm.base58ToArray(tx.assetId)])
@@ -57,45 +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;
-function broadcastTransfer(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.transaction())
-                .then((res) => {
-                const x = {
-                    isSuccess: true,
-                    response: {
-                        senderPublicKey: res.data.senderPublicKey,
-                        timestamp: res.data.timestamp,
-                        signature: res.data.signature,
-                        recipient: res.data.recipient,
-                        feeAsset: res.data.feeAsset,
-                        assetId: res.data.assetId,
-                        sender: res.data.sender,
-                        amount: res.data.amount,
-                        type: res.data.type,
-                        fee: res.data.fee,
-                        id: res.data.id
-                    }
-                };
-                resolve(x);
-            })
-                .catch(erro => {
-                resolve({
-                    isSuccess: false,
-                    response: {
-                        codeError: erro.response.data.error,
-                        message: erro.response.data.message
-                    }
-                });
-            });
-        }));
-    });
-}
-exports.broadcastTransfer = broadcastTransfer;

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.1",
+    "version": "1.9.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"
     }
 }