lunesjs 1.6.0 → 1.7.1

package/lib/index.d.ts

@@ -1,18 +1,17 @@
-import { transferTokenFactory } from "./tx/transfer/service.transfer";
+import { transferTokenFactory } from "./tx/transfer/transfer.service";
 import { walletFactory } from "./wallet/wallet.service";
 declare const _default: {
     transferTokenFactory: typeof transferTokenFactory;
     walletFactory: typeof walletFactory;
-    cryptoUtils: {
-        fromExistingSeed: (seed: string, nonce: number, chain: import("./wallet/wallet.types").WalletTypes.Chain) => import("./wallet/wallet.types").IAccount;
-        fromPrivateKey: (privateKey: string, chain: import("./wallet/wallet.types").WalletTypes.Chain) => import("./wallet/wallet.types").IAccount;
-        fromPublicKey: (publicKey: string, chain: import("./wallet/wallet.types").WalletTypes.Chain) => import("./wallet/wallet.types").IAccount;
-        fromAddress: (address: string, chain: import("./wallet/wallet.types").WalletTypes.Chain) => import("./wallet/wallet.types").IAccount;
-        fromNewSeed: (nWords: number, nonce: number, chain: import("./wallet/wallet.types").WalletTypes.Chain) => import("./wallet/wallet.types").IAccount;
-        validateAddress: (address: string, chain: import("./wallet/wallet.types").WalletTypes.Chain) => boolean;
+    crypto: {
+        fromSeed: (seed: string, nonce: number, chain: number) => import("./wallet/wallet.service").Wallet;
+        fromPrivateKey: (privateKey: string, chain: number) => import("./wallet/wallet.service").Wallet;
+        fromNewSeed: (seedLen: number, nonce: number, chain: number) => import("./wallet/wallet.service").Wallet;
+        validateAddress: (address: string, chain: number) => boolean;
         validateSignature: (publicKey: string, message: string, signature: string) => boolean;
         fastSignature: (privateKey: string, message: string) => string;
         fullSignature: (privateKey: string, message: string) => string;
+        sameChainAddress: (addr1: string, addr2: string) => boolean;
     };
 };
 export default _default;

package/lib/index.js

@@ -1,10 +1,10 @@
 "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 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,
     walletFactory: wallet_service_1.walletFactory,
-    cryptoUtils: crypto_1.cryptoUtils
+    crypto: crypto_1.crypto
 };

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

@@ -0,0 +1,60 @@
+export declare class TransferToken {
+    senderPublicKey: string;
+    timestamp: number;
+    signature: string;
+    recipient: string;
+    feeAsset: string;
+    message: string;
+    assetId: string;
+    amount: number;
+    sender: string;
+    type: number;
+    fee: number;
+    constructor(senderPublicKey: string, timestamp: number, receiver: string, feeAsset: string, assetId: string, amount: number, sender: string, fee: number);
+    transaction(): {
+        senderPublicKey: string;
+        timestamp: number;
+        signature: string;
+        recipient: string;
+        feeAsset: string;
+        assetId: string;
+        amount: number;
+        sender: string;
+        type: number;
+        fee: number;
+    };
+    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;
+        };
+    }>;
+}
+export declare type Transfer = {
+    senderPublicKey: string;
+    receiverAddress: string;
+    timestamp?: number;
+    feeAsset?: string;
+    assetId?: string;
+    chain?: number;
+    amount: number;
+    fee?: number;
+};
+export declare function transferTokenFactory(tx: Transfer): TransferToken;

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

@@ -0,0 +1,99 @@
+"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());
+    });
+};
+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"));
+class TransferToken {
+    constructor(senderPublicKey, timestamp, receiver, feeAsset, assetId, amount, sender, fee) {
+        this.senderPublicKey = senderPublicKey;
+        this.timestamp = timestamp;
+        this.signature = "";
+        this.recipient = receiver;
+        this.feeAsset = feeAsset;
+        this.message = "";
+        this.assetId = assetId;
+        this.amount = amount;
+        this.sender = sender;
+        this.type = 4;
+        this.fee = fee;
+    }
+    transaction() {
+        return {
+            senderPublicKey: this.senderPublicKey,
+            timestamp: this.timestamp,
+            signature: this.signature,
+            recipient: this.recipient,
+            feeAsset: this.feeAsset,
+            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);
+        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);
+        });
+    }
+}
+exports.TransferToken = TransferToken;
+function transferTokenFactory(tx) {
+    const timestamp = tx.timestamp != undefined ? tx.timestamp : Date.now();
+    const feeAsset = tx.feeAsset != undefined ? tx.feeAsset : "";
+    const assetId = tx.assetId != undefined ? tx.assetId : "";
+    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 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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,101 @@
+"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.broadcastTransfer = exports.signTransfer = 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)])
+        : new Uint8Array([0]);
+    const tokenFee = tx.feeAsset != ""
+        ? new Uint8Array([1, ...wasm.base58ToArray(tx.feeAsset)])
+        : new Uint8Array([0]);
+    return new Uint8Array([
+        ...[tx.type],
+        ...wasm.base58ToArray(tx.senderPublicKey),
+        ...tokenId,
+        ...tokenFee,
+        ...wasm.serializeUInteger(BigInt(tx.timestamp)),
+        ...wasm.serializeUInteger(BigInt(tx.amount)),
+        ...wasm.serializeUInteger(BigInt(tx.fee)),
+        ...wasm.base58ToArray(tx.recipient)
+    ]);
+}
+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/crypto.d.ts

@@ -1,12 +1,11 @@
-import { IAccount, WalletTypes } from "../wallet/wallet.types";
-export 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;
+import { Wallet } from "../wallet/wallet.service";
+export declare const crypto: {
+    fromSeed: (seed: string, nonce: number, chain: number) => Wallet;
+    fromPrivateKey: (privateKey: string, chain: number) => Wallet;
+    fromNewSeed: (seedLen: number, nonce: number, chain: number) => Wallet;
+    validateAddress: (address: string, chain: number) => boolean;
     validateSignature: (publicKey: string, message: string, signature: string) => boolean;
     fastSignature: (privateKey: string, message: string) => string;
     fullSignature: (privateKey: string, message: string) => string;
+    sameChainAddress: (addr1: string, addr2: string) => boolean;
 };

package/lib/utils/crypto.js

@@ -26,66 +26,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cryptoUtils = void 0;
+exports.crypto = void 0;
+const wallet_service_1 = require("../wallet/wallet.service");
 const constants_1 = __importDefault(require("../wallet/constants"));
 const wasm = __importStar(require("lunesrs"));
-exports.cryptoUtils = {
-    fromExistingSeed: (seed, nonce, chain) => {
+exports.crypto = {
+    fromSeed: (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)
-        };
+        return new wallet_service_1.Wallet(wasm.arrayToBase58(privateKey), wasm.arrayToBase58(publicKey), wasm.arrayToBase58(address), chain, nonce, seed);
     },
     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)
-        };
+        return new wallet_service_1.Wallet(privateKey, wasm.arrayToBase58(publicKey), wasm.arrayToBase58(address), chain, 0, "");
     },
-    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) => {
+    fromNewSeed: (seedLen, 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()) {
+        seedLen = seedLen != undefined ? Math.round(seedLen / 3) : 4;
+        for (let i = 0; i < seedLen; i++) {
+            for (let n of wasm.randomTripleNumber()) {
                 seed.push(constants_1.default.wordsList[n]);
             }
         }
-        return exports.cryptoUtils.fromExistingSeed(seed.join(" "), nonce, chain);
+        return exports.crypto.fromSeed(seed.join(" "), nonce, chain);
     },
     validateAddress: (address, chain) => {
         return wasm.validateAddress(chain, wasm.base58ToArray(address));
@@ -98,5 +64,10 @@ exports.cryptoUtils = {
     },
     fullSignature: (privateKey, message) => {
         return wasm.arrayToBase58(wasm.fullSignature(wasm.base58ToArray(privateKey), wasm.base58ToArray(message)));
+    },
+    sameChainAddress: (addr1, addr2) => {
+        const x = exports.crypto.validateAddress(addr1, 1) && exports.crypto.validateAddress(addr2, 1);
+        const y = exports.crypto.validateAddress(addr1, 0) && exports.crypto.validateAddress(addr2, 0);
+        return x || y;
     }
 };

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

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

package/lib/wallet/wallet.service.js

@@ -1,32 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.walletFactory = void 0;
+exports.walletFactory = exports.Wallet = void 0;
 const crypto_1 = 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;
+class Wallet {
+    constructor(privateKey, publicKey, address, chain, nonce, seed) {
+        this.privateKey = privateKey;
+        this.publicKey = publicKey;
+        this.address = address;
+        this.chain = chain;
+        this.nonce = nonce;
+        this.seed = seed;
     }
 }
-function walletFactory({ privateKey, publicKey, address, nWords, chain, nonce, seed } = {}) {
-    if (seed != undefined) {
-        return new Account(Object.assign({}, crypto_1.cryptoUtils.fromExistingSeed(seed, nonce != undefined ? nonce : 0, chain != undefined ? chain : 1)));
+exports.Wallet = Wallet;
+function walletFactory(wallet) {
+    if (wallet.seed) {
+        return crypto_1.crypto.fromSeed(wallet.seed, wallet.nonce != undefined ? wallet.nonce : 0, wallet.chain != undefined ? wallet.chain : 1);
     }
-    else if (privateKey != undefined) {
-        return new Account(Object.assign({}, crypto_1.cryptoUtils.fromPrivateKey(privateKey, chain != undefined ? chain : 1)));
-    }
-    else if (publicKey != undefined) {
-        return new Account(Object.assign({}, crypto_1.cryptoUtils.fromPublicKey(publicKey, chain != undefined ? chain : 1)));
-    }
-    else if (address != undefined) {
-        return new Account(Object.assign({}, crypto_1.cryptoUtils.fromAddress(address, chain != undefined ? chain : 0)));
+    else if (wallet.privateKey) {
+        return crypto_1.crypto.fromPrivateKey(wallet.privateKey, wallet.chain != undefined ? wallet.chain : 1);
     }
     else {
-        return new Account(Object.assign({}, crypto_1.cryptoUtils.fromNewSeed(nWords != undefined ? nWords : 12, nonce != undefined ? nonce : 0, chain != undefined ? chain : 1)));
+        return crypto_1.crypto.fromNewSeed(wallet.seedLen != undefined ? wallet.seedLen : 12, wallet.nonce != undefined ? wallet.nonce : 0, wallet.chain != undefined ? wallet.chain : 1);
     }
 }
 exports.walletFactory = walletFactory;

package/package.json

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

package/lib/tx/BaseTransaction.d.ts

@@ -1,6 +0,0 @@
-import { WalletTypes } from "../wallet/wallet.types";
-export interface BaseTransaction {
-    sign(privateKey: WalletTypes.PrivateKey): object;
-    transaction(): object;
-    send(): object;
-}

package/lib/tx/BaseTransaction.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/tx/transactions.types.d.ts

@@ -1,10 +0,0 @@
-export declare namespace TransactionsTypes {
-    enum TransferToken {
-        int = 4,
-        fee = 1000000
-    }
-    enum IssueToken {
-        int = 5,
-        fee = 1000000000
-    }
-}

package/lib/tx/transactions.types.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionsTypes = void 0;
-var TransactionsTypes;
-(function (TransactionsTypes) {
-    let TransferToken;
-    (function (TransferToken) {
-        TransferToken[TransferToken["int"] = 4] = "int";
-        TransferToken[TransferToken["fee"] = 1000000] = "fee";
-    })(TransferToken = TransactionsTypes.TransferToken || (TransactionsTypes.TransferToken = {}));
-    let IssueToken;
-    (function (IssueToken) {
-        IssueToken[IssueToken["int"] = 5] = "int";
-        IssueToken[IssueToken["fee"] = 1000000000] = "fee";
-    })(IssueToken = TransactionsTypes.IssueToken || (TransactionsTypes.IssueToken = {}));
-    //...
-})(TransactionsTypes = exports.TransactionsTypes || (exports.TransactionsTypes = {}));

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

@@ -1,12 +0,0 @@
-import { WalletTypes } from "../../wallet/wallet.types";
-import { BaseTransaction } from "../BaseTransaction";
-import { ITransfer } from "./transfer.types";
-declare class TransferToken implements BaseTransaction {
-    private tx;
-    constructor(tx: ITransfer);
-    transaction(): ITransfer;
-    sign(privateKey: WalletTypes.PrivateKey): ITransfer;
-    send(): Promise<void>;
-}
-export declare function transferTokenFactory(senderPublicKey: string, recipient: string, amount: number, assetId?: string, chain?: WalletTypes.Chain, timestamp?: number, feeAsset?: string, fee?: number): TransferToken;
-export {};

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

@@ -1,78 +0,0 @@
-"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.transferTokenFactory = void 0;
-const transactions_types_1 = require("../transactions.types");
-const wallet_types_1 = require("../../wallet/wallet.types");
-const validator_1 = __importDefault(require("./validator"));
-const wasm = __importStar(require("lunesrs"));
-class TransferToken {
-    constructor(tx) {
-        this.tx = tx;
-    }
-    transaction() {
-        return this.tx;
-    }
-    sign(privateKey) {
-        this.tx.signature = validator_1.default.sign(privateKey, this.tx);
-        return this.tx;
-    }
-    send() {
-        return __awaiter(this, void 0, void 0, function* () {
-            validator_1.default.send(this.tx);
-        });
-    }
-}
-function transferTokenFactory(senderPublicKey, recipient, amount, assetId, chain, timestamp, feeAsset, fee) {
-    const chain_id = chain != undefined ? chain : wallet_types_1.WalletTypes.Chain.Mainnet;
-    if (false == validator_1.default.ready(senderPublicKey, recipient, amount, chain_id)) {
-        throw new Error("dados invalidos");
-    }
-    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: transactions_types_1.TransactionsTypes.TransferToken.int,
-        fee: fee != undefined ? fee : transactions_types_1.TransactionsTypes.TransferToken.fee,
-        signature: ""
-    });
-}
-exports.transferTokenFactory = transferTokenFactory;

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

@@ -1,12 +0,0 @@
-export interface ITransfer {
-    senderPublicKey: string;
-    timestamp: number;
-    signature: string;
-    recipient: string;
-    feeAsset: string;
-    assetId: string;
-    amount: number;
-    sender: string;
-    type: number;
-    fee: number;
-}

package/lib/tx/transfer/transfer.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,9 +0,0 @@
-import { WalletTypes } from "../../wallet/wallet.types";
-import { ITransfer } from "./transfer.types";
-declare const validator: {
-    serialize: (senderPublicKey: string, assetId: string, feeAsset: string, timestamp: number, amount: number, fee: number, recipient: string) => Uint8Array;
-    ready: (senderPublicKey: string, recipient: string, amount: number, chain: WalletTypes.Chain) => boolean;
-    sign: (privateKey: WalletTypes.PrivateKey, tx: ITransfer) => string;
-    send: (tx: ITransfer) => Promise<void>;
-};
-export default validator;

package/lib/tx/transfer/validator.js

@@ -1,93 +0,0 @@
-"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 });
-const transactions_types_1 = require("../transactions.types");
-const crypto_1 = require("../../utils/crypto");
-const wasm = __importStar(require("lunesrs"));
-const axios_1 = __importDefault(require("axios"));
-const validator = {
-    serialize: (senderPublicKey, assetId, feeAsset, timestamp, amount, fee, recipient) => {
-        const tokenId = assetId != ""
-            ? new Uint8Array([1, ...wasm.base58ToArray(assetId)])
-            : new Uint8Array([0]);
-        const tokenFee = feeAsset != ""
-            ? new Uint8Array([1, ...wasm.base58ToArray(feeAsset)])
-            : new Uint8Array([0]);
-        return new Uint8Array([
-            ...[transactions_types_1.TransactionsTypes.TransferToken.int],
-            ...wasm.base58ToArray(senderPublicKey),
-            ...tokenId,
-            ...tokenFee,
-            ...wasm.serializeUInteger(BigInt(timestamp)),
-            ...wasm.serializeUInteger(BigInt(amount)),
-            ...wasm.serializeUInteger(BigInt(fee)),
-            ...wasm.base58ToArray(recipient)
-        ]);
-    },
-    ready: (senderPublicKey, recipient, amount, chain) => {
-        const sender = wasm.arrayToBase58(wasm.toAddress(1, chain, wasm.base58ToArray(senderPublicKey)));
-        if (amount <= 0) {
-            return false;
-        }
-        else if (!(crypto_1.cryptoUtils.validateAddress(sender, chain) === true &&
-            crypto_1.cryptoUtils.validateAddress(recipient, chain) === true)) {
-            return false;
-        }
-        else {
-            return true;
-        }
-    },
-    sign: (privateKey, tx) => {
-        const message = validator.serialize(tx.senderPublicKey, tx.assetId, tx.feeAsset, tx.timestamp, tx.amount, tx.fee, tx.recipient);
-        return crypto_1.cryptoUtils.fastSignature(privateKey, wasm.arrayToBase58(new Uint8Array(message)));
-    },
-    send: (tx) => __awaiter(void 0, void 0, void 0, function* () {
-        yield axios_1.default
-            .request({
-            url: "https://lunesnode.lunes.io/transactions/broadcast",
-            method: "post",
-            data: tx
-        })
-            .then((x) => {
-            console.log(x);
-        })
-            .catch((error) => {
-            console.error(error.response.data);
-        });
-    })
-};
-exports.default = validator;

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

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

package/lib/wallet/wallet.types.js

@@ -1,11 +0,0 @@
-"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 = {}));