lunesjs 1.5.7 → 1.5.10

package/dist/client/wallet/service.account.d.ts

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

package/dist/client/wallet/service.account.js

@@ -1,35 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.accountFactory = void 0;
-const crypto_1 = __importDefault(require("../../utils/crypto"));
-class Account {
-    constructor(wallet) {
-        this.privateKey = wallet.privateKey;
-        this.publicKey = wallet.publicKey;
-        this.address = wallet.address;
-        this.chain = wallet.chain;
-        this.nonce = wallet.nonce;
-        this.seed = wallet.seed;
-    }
-}
-function accountFactory({ privateKey, publicKey, address, nWords, chain, nonce, seed } = {}) {
-    if (seed != undefined) {
-        return new Account(Object.assign({}, crypto_1.default.fromExistingSeed(seed, nonce != undefined ? nonce : 0, chain != undefined ? chain : 1)));
-    }
-    else if (privateKey != undefined) {
-        return new Account(Object.assign({}, crypto_1.default.fromPrivateKey(privateKey, chain != undefined ? chain : 1)));
-    }
-    else if (publicKey != undefined) {
-        return new Account(Object.assign({}, crypto_1.default.fromPublicKey(publicKey, chain != undefined ? chain : 1)));
-    }
-    else if (address != undefined) {
-        return new Account(Object.assign({}, crypto_1.default.fromAddress(address, chain != undefined ? chain : 0)));
-    }
-    else {
-        return new Account(Object.assign({}, crypto_1.default.fromNewSeed(nWords != undefined ? nWords : 12, nonce != undefined ? nonce : 0, chain != undefined ? chain : 1)));
-    }
-}
-exports.accountFactory = accountFactory;

package/dist/client/wallet/wallet.types.d.ts

@@ -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/dist/client/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 = {}));

package/dist/utils/crypto.d.ts

@@ -1,13 +0,0 @@
-import { IAccount, WalletTypes } from "../client/wallet/wallet.types";
-declare const cryptoUtils: {
-    fromExistingSeed: (seed: string, nonce: number, chain: WalletTypes.Chain) => IAccount;
-    fromPrivateKey: (privateKey: string, chain: WalletTypes.Chain) => IAccount;
-    fromPublicKey: (publicKey: string, chain: WalletTypes.Chain) => IAccount;
-    fromAddress: (address: string, chain: WalletTypes.Chain) => IAccount;
-    fromNewSeed: (nWords: number, nonce: number, chain: WalletTypes.Chain) => IAccount;
-    validateAddress: (address: string, chain: WalletTypes.Chain) => boolean;
-    validateSignature: (publicKey: string, message: string, signature: string) => boolean;
-    fastSignature: (privateKey: string, message: string) => string;
-    fullSignature: (privateKey: string, message: string) => string;
-};
-export default cryptoUtils;

package/dist/utils/crypto.js

@@ -1,102 +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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = __importDefault(require("../client/wallet/constants"));
-const wasm = __importStar(require("lunesrs"));
-const cryptoUtils = {
-    fromExistingSeed: (seed, nonce, chain) => {
-        const hidden_seed = wasm.hiddenSeed(nonce, seed);
-        const privateKey = wasm.toPrivateKey(hidden_seed);
-        const publicKey = wasm.toPublicKey(privateKey);
-        const address = wasm.toAddress(1, chain, publicKey);
-        return {
-            nonce: nonce,
-            chain: chain,
-            seed: seed,
-            privateKey: wasm.arrayToBase58(privateKey),
-            publicKey: wasm.arrayToBase58(publicKey),
-            address: wasm.arrayToBase58(address)
-        };
-    },
-    fromPrivateKey: (privateKey, chain) => {
-        const publicKey = wasm.toPublicKey(wasm.base58ToArray(privateKey));
-        const address = wasm.toAddress(1, chain, publicKey);
-        return {
-            seed: "",
-            nonce: 0,
-            chain: chain,
-            privateKey: privateKey,
-            publicKey: wasm.arrayToBase58(publicKey),
-            address: wasm.arrayToBase58(address)
-        };
-    },
-    fromPublicKey: (publicKey, chain) => {
-        const address = wasm.toAddress(1, chain, wasm.base58ToArray(publicKey));
-        return {
-            seed: "",
-            nonce: 0,
-            privateKey: "",
-            chain: chain,
-            publicKey: publicKey,
-            address: wasm.arrayToBase58(address)
-        };
-    },
-    fromAddress: (address, chain) => {
-        return {
-            seed: "",
-            nonce: 0,
-            privateKey: "",
-            publicKey: "",
-            chain: chain,
-            address: address
-        };
-    },
-    fromNewSeed: (nWords, nonce, chain) => {
-        let seed = [];
-        nWords = nWords != undefined ? Math.round(nWords / 3) : 4;
-        for (let i = 0; i < nWords; i++) {
-            for (let n in wasm.randomTripleNumber()) {
-                seed.push(constants_1.default.wordsList[n]);
-            }
-        }
-        return cryptoUtils.fromExistingSeed(seed.join(" "), nonce, chain);
-    },
-    validateAddress: (address, chain) => {
-        return wasm.validateAddress(chain, wasm.base58ToArray(address));
-    },
-    validateSignature: (publicKey, message, signature) => {
-        return wasm.validateSignature(wasm.base58ToArray(publicKey), wasm.base58ToArray(message), wasm.base58ToArray(signature));
-    },
-    fastSignature: (privateKey, message) => {
-        return wasm.arrayToBase58(wasm.fastSignature(wasm.base58ToArray(privateKey), wasm.base58ToArray(message)));
-    },
-    fullSignature: (privateKey, message) => {
-        return wasm.arrayToBase58(wasm.fullSignature(wasm.base58ToArray(privateKey), wasm.base58ToArray(message)));
-    }
-};
-exports.default = cryptoUtils;

package/jest.config.js

@@ -1,11 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-const root = "./"
-
-module.exports = {
-    reporters: ["default", "jest-junit"],
-    rootDir: root,
-    displayName: "based-tests",
-    testMatch: ["<rootDir>/test/**/*.test.ts"],
-    testEnvironment: "node",
-    preset: "ts-jest"
-}

package/src/client/transactions/BaseTransaction.ts

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

package/src/client/transactions/transactions.types.ts

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

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

@@ -1,58 +0,0 @@
-import { TransactionsTypes } from "../transactions.types"
-import { WalletTypes } from "../../wallet/wallet.types"
-import { BaseTransaction } from "../BaseTransaction"
-import { ITransfer } from "./transfer.types"
-import validator from "./validator"
-import * as wasm from "lunesrs"
-
-class TransferToken implements BaseTransaction {
-    private tx: ITransfer
-    constructor(tx: ITransfer) {
-        this.tx = tx
-    }
-
-    transaction(): ITransfer {
-        return this.tx
-    }
-
-    sign(privateKey: WalletTypes.PrivateKey): ITransfer {
-        this.tx.signature = validator.sign(privateKey, this.tx)
-        return this.tx
-    }
-
-    async send() {
-        validator.send(this.tx)
-    }
-}
-
-export function transferTokenFactory(
-    senderPublicKey: string,
-    recipient: string,
-    amount: number,
-    chain?: WalletTypes.Chain,
-    timestamp?: number,
-    feeAsset?: string,
-    assetId?: string,
-    fee?: number
-): TransferToken {
-    const chain_id = chain != undefined ? chain : WalletTypes.Chain.Mainnet
-    if (
-        false == validator.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: TransactionsTypes.TransferToken.int,
-        fee: fee != undefined ? fee : TransactionsTypes.TransferToken.fee,
-        signature: ""
-    })
-}

package/src/client/transactions/transfer/transfer.types.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/src/client/transactions/transfer/validator.ts

@@ -1,92 +0,0 @@
-import { WalletTypes } from "../../wallet/wallet.types"
-import { TransactionsTypes } from "../transactions.types"
-import cryptoUtils from "../../../utils/crypto"
-import { ITransfer } from "./transfer.types"
-import * as wasm from "lunesrs"
-import axios from "axios"
-
-const validator = {
-    serialize: (
-        senderPublicKey: string,
-        assetId: string,
-        feeAsset: string,
-        timestamp: number,
-        amount: number,
-        fee: number,
-        recipient: string
-    ) => {
-        const tokenId: Uint8Array =
-            assetId != ""
-                ? new Uint8Array([1, ...wasm.base58ToArray(assetId)])
-                : new Uint8Array([0])
-        const tokenFee: Uint8Array =
-            feeAsset != ""
-                ? new Uint8Array([1, ...wasm.base58ToArray(feeAsset)])
-                : new Uint8Array([0])
-
-        return new Uint8Array([
-            ...[TransactionsTypes.TransferToken.int],
-            ...wasm.base58ToArray(senderPublicKey),
-            ...tokenId,
-            ...tokenFee,
-            ...wasm.serializeUInteger(BigInt(timestamp)),
-            ...wasm.serializeUInteger(BigInt(amount)),
-            ...wasm.serializeUInteger(BigInt(fee)),
-            ...wasm.base58ToArray(recipient)
-        ])
-    },
-    ready: (
-        senderPublicKey: string,
-        recipient: string,
-        amount: number,
-        chain: WalletTypes.Chain
-    ): boolean => {
-        const sender = wasm.arrayToBase58(
-            wasm.toAddress(1, chain, wasm.base58ToArray(senderPublicKey))
-        )
-        if (amount <= 0) {
-            return false
-        } else if (
-            !(
-                cryptoUtils.validateAddress(sender, chain) === true &&
-                cryptoUtils.validateAddress(recipient, chain) === true
-            )
-        ) {
-            return false
-        } else {
-            return true
-        }
-    },
-    sign: (privateKey: WalletTypes.PrivateKey, tx: ITransfer): string => {
-        const message = validator.serialize(
-            tx.senderPublicKey,
-            tx.assetId,
-            tx.feeAsset,
-            tx.timestamp,
-            tx.amount,
-            tx.fee,
-            tx.recipient
-        )
-
-        return cryptoUtils.fastSignature(
-            privateKey,
-            wasm.arrayToBase58(new Uint8Array(message))
-        )
-    },
-    send: async (tx: ITransfer) => {
-        await axios
-            .request({
-                url: "https://lunesnode.lunes.io/transactions/broadcast",
-                method: "post",
-                data: tx
-            })
-            .then((x) => {
-                console.log(x)
-            })
-            .catch((error) => {
-                console.error(error.response.data)
-            })
-    }
-}
-
-export default validator