lunesjs 1.8.0 → 1.9.0

package/lib/index.d.ts

@@ -2,10 +2,18 @@ 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

@@ -5,10 +5,18 @@ 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.js

@@ -80,18 +80,14 @@ function createStakeFactory(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 Stake(tx.senderPublicKey, timestamp, tx.receiverAddress, Math.floor(tx.amount * 10e7), fee);
 }
 exports.createStakeFactory = createStakeFactory;

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

@@ -51,12 +51,10 @@ 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) {
+    if (timestamp < 1483228800)
         throw new Error(`Timestamp should be greater than 1483228800, but ${timestamp}`);
-    }
-    if (fee < 100000) {
+    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.js

@@ -88,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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lunesjs",
-    "version": "1.8.0",
+    "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",