lunesjs 1.5.7 → 1.5.10

package/src/client/wallet/service.account.ts

@@ -1,74 +0,0 @@
-import { IAccount } from "./wallet.types"
-import cryptoUtils from "../../utils/crypto"
-
-class Account implements IAccount {
-    privateKey: string
-    publicKey: string
-    address: string
-    chain: number
-    nonce: number
-    seed: string
-
-    constructor(wallet: IAccount) {
-        this.privateKey = wallet.privateKey
-        this.publicKey = wallet.publicKey
-        this.address = wallet.address
-        this.chain = wallet.chain
-        this.nonce = wallet.nonce
-        this.seed = wallet.seed
-    }
-}
-
-export function accountFactory({
-    privateKey,
-    publicKey,
-    address,
-    nWords,
-    chain,
-    nonce,
-    seed
-}: {
-    privateKey?: string
-    publicKey?: string
-    address?: string
-    nWords?: number
-    chain?: number
-    nonce?: number
-    seed?: string
-} = {}): Account {
-    if (seed != undefined) {
-        return new Account({
-            ...cryptoUtils.fromExistingSeed(
-                seed,
-                nonce != undefined ? nonce : 0,
-                chain != undefined ? chain : 1
-            )
-        })
-    } else if (privateKey != undefined) {
-        return new Account({
-            ...cryptoUtils.fromPrivateKey(
-                privateKey,
-                chain != undefined ? chain : 1
-            )
-        })
-    } else if (publicKey != undefined) {
-        return new Account({
-            ...cryptoUtils.fromPublicKey(
-                publicKey,
-                chain != undefined ? chain : 1
-            )
-        })
-    } else if (address != undefined) {
-        return new Account({
-            ...cryptoUtils.fromAddress(address, chain != undefined ? chain : 0)
-        })
-    } else {
-        return new Account({
-            ...cryptoUtils.fromNewSeed(
-                nWords != undefined ? nWords : 12,
-                nonce != undefined ? nonce : 0,
-                chain != undefined ? chain : 1
-            )
-        })
-    }
-}

package/src/client/wallet/wallet.types.ts

@@ -1,23 +0,0 @@
-export type empty = ""
-export type zero = 0
-
-export namespace WalletTypes {
-    export type Seed = string | empty
-    export type Nonce = number | zero // 0 ... 4.294.967.295
-    export enum Chain {
-        Mainnet = 1,
-        Testnet = 0
-    }
-    export type PrivateKey = string | empty
-    export type PublicKey = string | empty
-    export 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/src/utils/crypto.ts

@@ -1,109 +0,0 @@
-import { IAccount, WalletTypes } from "../client/wallet/wallet.types"
-import walletConstants from "../client/wallet/constants"
-import * as wasm from "lunesrs"
-
-const cryptoUtils = {
-    fromExistingSeed: (
-        seed: string,
-        nonce: number,
-        chain: WalletTypes.Chain
-    ): IAccount => {
-        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: string,
-        chain: WalletTypes.Chain
-    ): IAccount => {
-        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: string, chain: WalletTypes.Chain): IAccount => {
-        const address = wasm.toAddress(1, chain, wasm.base58ToArray(publicKey))
-
-        return {
-            seed: "",
-            nonce: 0,
-            privateKey: "",
-            chain: chain,
-            publicKey: publicKey,
-            address: wasm.arrayToBase58(address)
-        }
-    },
-    fromAddress: (address: string, chain: WalletTypes.Chain): IAccount => {
-        return {
-            seed: "",
-            nonce: 0,
-            privateKey: "",
-            publicKey: "",
-            chain: chain,
-            address: address
-        }
-    },
-    fromNewSeed: (
-        nWords: number,
-        nonce: number,
-        chain: WalletTypes.Chain
-    ): IAccount => {
-        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(walletConstants.wordsList[n])
-            }
-        }
-        return cryptoUtils.fromExistingSeed(seed.join(" "), nonce, chain)
-    },
-    validateAddress: (address: string, chain: WalletTypes.Chain): boolean => {
-        return wasm.validateAddress(chain, wasm.base58ToArray(address))
-    },
-    validateSignature: (
-        publicKey: string,
-        message: string,
-        signature: string
-    ): boolean => {
-        return wasm.validateSignature(
-            wasm.base58ToArray(publicKey),
-            wasm.base58ToArray(message),
-            wasm.base58ToArray(signature)
-        )
-    },
-    fastSignature: (privateKey: string, message: string) => {
-        return wasm.arrayToBase58(
-            wasm.fastSignature(
-                wasm.base58ToArray(privateKey),
-                wasm.base58ToArray(message)
-            )
-        )
-    },
-    fullSignature: (privateKey: string, message: string) => {
-        return wasm.arrayToBase58(
-            wasm.fullSignature(
-                wasm.base58ToArray(privateKey),
-                wasm.base58ToArray(message)
-            )
-        )
-    }
-}
-
-export default cryptoUtils

package/test/client/transactions/transfer/transfer.token.test.ts

@@ -1,97 +0,0 @@
-import { transferTokenFactory } from "../../../../src/client/transactions/transfer/service.transfer"
-import { TransactionsTypes } from "../../../../src/client/transactions/transactions.types"
-import { accountFactory } from "../../../../src/client/wallet/service.account"
-import validator from "../../../../src/client/transactions/transfer/validator"
-import { WalletTypes } from "../../../../src/client/wallet/wallet.types"
-import * as wasm from "lunesrs"
-
-describe("Transfer Token Suite", () => {
-    const senderAccount = accountFactory({
-        privateKey: "8YMbX5BCQdazwgdVfeUpKuoUJrmYpMyGVAGAsNaHVj1u",
-        chain: WalletTypes.Chain.Mainnet
-    })
-
-    const recipientAccount = accountFactory({
-        privateKey: "G6E2xNBWtsRG8XBDmeTQQxZNHHUa6K9dnc9KrYtKyGwM",
-        chain: WalletTypes.Chain.Mainnet
-    })
-
-    const rawTx = {
-        type: TransactionsTypes.TransferToken.int,
-        sender: senderAccount.address,
-        senderPublicKey: senderAccount.publicKey,
-        recipient: recipientAccount.address,
-        amount: 100000000000,
-        timestamp: 1648349834003,
-        fee: TransactionsTypes.TransferToken.fee,
-        signature: "",
-        assetId: "",
-        feeAsset: ""
-    }
-
-    const message = validator.serialize(
-        rawTx.senderPublicKey,
-        rawTx.assetId,
-        rawTx.feeAsset,
-        rawTx.timestamp,
-        rawTx.amount,
-        rawTx.fee,
-        rawTx.recipient
-    )
-
-    const tx = transferTokenFactory(
-        senderAccount.publicKey,
-        recipientAccount.address,
-        100000000000,
-        undefined,
-        1648349834003
-    )
-
-    it("Create a Transfer Transaction", () => {
-        expect(tx.transaction().recipient).toEqual(recipientAccount.address)
-        expect(tx.transaction().sender).toEqual(senderAccount.address)
-        expect(tx.transaction().amount).toEqual(100000000000)
-        expect(tx.transaction().type).toEqual(4)
-    })
-
-    it("Serialize Transfer Transaction ", () => {
-        expect(wasm.arrayToBase58(Uint8Array.from(message))).toEqual(
-            "2J2EfWqeqbH17PC5yfioAeQ5h27J76uduH5nafAUuJhKb8gHCSqpDFV4oGgWPwQkBgg9tfQjatWZu8eiYYe6NF67Sd5Hf7ieAsaZT5hZow9xgjefbfs5"
-        )
-        expect(message).toEqual(
-            new Uint8Array([
-                4, 28, 26, 172, 20, 253, 115, 23, 6, 248, 59, 119, 129, 151,
-                144, 5, 252, 208, 116, 12, 81, 146, 227, 208, 88, 57, 27, 134,
-                143, 7, 76, 94, 8, 0, 0, 0, 0, 1, 127, 201, 78, 107, 19, 0, 0,
-                0, 23, 72, 118, 232, 0, 0, 0, 0, 0, 0, 15, 66, 64, 1, 49, 146,
-                80, 170, 11, 139, 27, 185, 41, 131, 242, 219, 45, 180, 199, 38,
-                41, 173, 240, 198, 30, 146, 73, 23, 128
-            ])
-        )
-        expect(rawTx).toStrictEqual({
-            senderPublicKey: "2ti1GM7F7J78J347fqSWSVocueDV3RSCFkLSKqmhk35Z",
-            recipient: "37xRcbn1LiT1Az4REoLhjpca93jPG1gTEwq",
-            sender: "37tQRv7x2RHd32Ss2i1EFTWSTSsqkwXcaBe",
-            timestamp: 1648349834003,
-            amount: 100000000000,
-            signature: "",
-            fee: 1000000,
-            feeAsset: "",
-            assetId: "",
-            type: 4
-        })
-    })
-
-    it("Signed a Transfer Transaction", () => {
-        expect(tx.transaction()).toEqual(rawTx)
-        const sign = tx.sign(senderAccount.privateKey).signature
-        expect(tx.transaction().signature).not.toBe("")
-
-        const result = wasm.validateSignature(
-            wasm.base58ToArray(senderAccount.publicKey),
-            new Uint8Array(message),
-            wasm.base58ToArray(sign)
-        )
-        expect(result).toBe(true)
-    })
-})

package/test/client/wallet/service.account.test.ts

@@ -1,330 +0,0 @@
-import { accountFactory } from "../../../src/client/wallet/service.account"
-import { WalletTypes } from "../../../src/client/wallet/wallet.types"
-import cryptoUtils from "../../../src/utils/crypto"
-import * as wasm from "lunesrs"
-
-describe("Create Account from New Seed", () => {
-    const createMainnetAccountFromNewSeed = () => {
-        return accountFactory()
-    }
-    const createTestnetAccountFromNewSeed = () => {
-        return accountFactory({ chain: WalletTypes.Chain.Testnet })
-    }
-
-    it("Test Address of Mainnet Account from New Seed", () => {
-        const w = createMainnetAccountFromNewSeed()
-        expect(
-            cryptoUtils.validateAddress(
-                w.address != undefined ? w.address : "",
-                WalletTypes.Chain.Mainnet
-            )
-        ).toEqual(true)
-    })
-    it("Test Address of Testnet Account from New Seed", () => {
-        const w = createTestnetAccountFromNewSeed()
-        expect(
-            cryptoUtils.validateAddress(
-                w.address != undefined ? w.address : "",
-                WalletTypes.Chain.Testnet
-            )
-        ).toEqual(true)
-    })
-})
-
-describe("Create Account from Seed", () => {
-    const seed =
-        "scrub guard swim catch range upon dawn ensure segment alpha sentence spend effort bar benefit"
-
-    const createMainnetAccountFromSeed = (seed: string, nonce?: number) => {
-        return accountFactory({
-            seed: seed,
-            nonce: nonce != undefined ? nonce : 0,
-            chain: WalletTypes.Chain.Mainnet
-        })
-    }
-
-    const createTestnetAccountFromSeed = (seed: string, nonce?: number) => {
-        return accountFactory({
-            seed: seed,
-            nonce: nonce != undefined ? nonce : 0,
-            chain: WalletTypes.Chain.Testnet
-        })
-    }
-
-    it("Test Create Mainnet Account from seed", () => {
-        const prvk = "BnafXBSq1VDUdZ1nSjJoxhnQdBv2hk3o6dbV49TD1bzo"
-        const pubk = "2uuQVr3B5aGgvSJ5BMCw4Cd19tdYdnMGoYnji99aPde4"
-        const addr = "37o7aY3eZZTXmzrDa5e4Wj3Z4ZZuyV42Aaj"
-        const w = createMainnetAccountFromSeed(seed, 0)
-        expect(w.privateKey).toEqual(prvk)
-        expect(w.publicKey).toEqual(pubk)
-        expect(w.address).toEqual(addr)
-    })
-
-    it("Test Create Testnet Account from seed", () => {
-        const prvk = "BnafXBSq1VDUdZ1nSjJoxhnQdBv2hk3o6dbV49TD1bzo"
-        const pubk = "2uuQVr3B5aGgvSJ5BMCw4Cd19tdYdnMGoYnji99aPde4"
-        const addr = "37PmyYwMGrH4uBR5V4DjCEvHGw4f2pdXW5u"
-        const w = createTestnetAccountFromSeed(seed, 0)
-        expect(w.privateKey).toEqual(prvk)
-        expect(w.publicKey).toEqual(pubk)
-        expect(w.address).toEqual(addr)
-    })
-
-    const mainnetNonce12345Address: [number, string][] = [
-        [0, "37o7aY3eZZTXmzrDa5e4Wj3Z4ZZuyV42Aaj"],
-        [1, "37tD32367v1fiWgW8waw3QTdYTKKGrCV3zw"],
-        [2, "37qYK5eRJEr8a38hUXmxYv9aoQ8NpXH7Aqd"],
-        [3, "37w8stLd9JQwUKBrBUQr1VryJuhS3RWqEen"],
-        [4, "37vVbQVXEE4Lvs7X4wimsoxAvqBmoyHsWDJ"]
-    ]
-    test.each(mainnetNonce12345Address)(
-        "Test Create Mainnet Account with range of nonces",
-        (nonce, address) => {
-            expect(createMainnetAccountFromSeed(seed, nonce).address).toEqual(
-                address
-            )
-        }
-    )
-
-    const testnetNonce12345Address: [number, string][] = [
-        [0, "37PmyYwMGrH4uBR5V4DjCEvHGw4f2pdXW5u"],
-        [1, "37UsS2vnqCqCqhFN3vAbivLMkpp4L8GMCyP"],
-        [2, "37SCi6Y81XffhDhZPWMdES2K1md7skK1mFu"],
-        [3, "37XoGuEKrbEUbVki6SzWh1jhXHCB6jnKFxS"],
-        [4, "37X9zRPDwWst43gNyvJSZKpu9CgWsHt1U8i"]
-    ]
-    test.each(testnetNonce12345Address)(
-        "Test Create Testnet Account with range of nonces",
-        (nonce, address) => {
-            expect(createTestnetAccountFromSeed(seed, nonce).address).toEqual(
-                address
-            )
-        }
-    )
-})
-
-describe("Create Account from Private Key", () => {
-    const privateKey = "BnafXBSq1VDUdZ1nSjJoxhnQdBv2hk3o6dbV49TD1bzo"
-    const publicKey = "2uuQVr3B5aGgvSJ5BMCw4Cd19tdYdnMGoYnji99aPde4"
-
-    const createMainnetAccountFromPrivateKey = (privateKey: string) => {
-        return accountFactory({
-            privateKey: privateKey,
-            chain: WalletTypes.Chain.Mainnet
-        })
-    }
-
-    const createTestnetAccountFromPrivateKey = (privateKey: string) => {
-        return accountFactory({
-            privateKey: privateKey,
-            chain: WalletTypes.Chain.Testnet
-        })
-    }
-
-    it("Test Create Mainnet Account from Private Key", () => {
-        const w = createMainnetAccountFromPrivateKey(privateKey)
-        const addr = "37o7aY3eZZTXmzrDa5e4Wj3Z4ZZuyV42Aaj"
-        expect(w.privateKey).toEqual(privateKey)
-        expect(w.publicKey).toEqual(publicKey)
-        expect(w.address).toEqual(addr)
-    })
-
-    it("Test Create Testnet Account from Private Key", () => {
-        const w = createTestnetAccountFromPrivateKey(privateKey)
-        const addr = "37PmyYwMGrH4uBR5V4DjCEvHGw4f2pdXW5u"
-        expect(w.privateKey).toEqual(privateKey)
-        expect(w.publicKey).toEqual(publicKey)
-        expect(w.address).toEqual(addr)
-    })
-})
-
-describe("Create Account from Public Key", () => {
-    const publicKey = "2uuQVr3B5aGgvSJ5BMCw4Cd19tdYdnMGoYnji99aPde4"
-
-    const createMainnetAccountFromPublicKey = (publicKey: string) => {
-        return accountFactory({
-            publicKey: publicKey,
-            chain: WalletTypes.Chain.Mainnet
-        })
-    }
-
-    const createTestnetAccountFromPublicKey = (publicKey: string) => {
-        return accountFactory({
-            publicKey: publicKey,
-            chain: WalletTypes.Chain.Testnet
-        })
-    }
-
-    it("Test Create Mainnet Account From Public Key", () => {
-        expect(createMainnetAccountFromPublicKey(publicKey).address).toEqual(
-            "37o7aY3eZZTXmzrDa5e4Wj3Z4ZZuyV42Aaj"
-        )
-    })
-
-    it("Test Create Testnet Account From Public Key", () => {
-        expect(createTestnetAccountFromPublicKey(publicKey).address).toEqual(
-            "37PmyYwMGrH4uBR5V4DjCEvHGw4f2pdXW5u"
-        )
-    })
-})
-
-describe("Create Account from Address", () => {
-    const createMainnetAccountFromAdress = () => {
-        return accountFactory({
-            address: "37o7aY3eZZTXmzrDa5e4Wj3Z4ZZuyV42Aaj",
-            chain: WalletTypes.Chain.Mainnet
-        })
-    }
-
-    const createTestnetAccountFromAdress = () => {
-        return accountFactory({
-            address: "37PmyYwMGrH4uBR5V4DjCEvHGw4f2pdXW5u",
-            chain: WalletTypes.Chain.Mainnet
-        })
-    }
-
-    it("Test Create Mainnet Account from Address", () => {
-        expect(createMainnetAccountFromAdress().address).toEqual(
-            "37o7aY3eZZTXmzrDa5e4Wj3Z4ZZuyV42Aaj"
-        )
-    })
-
-    it("Test Create Testnet Account from Address", () => {
-        expect(createTestnetAccountFromAdress().address).toEqual(
-            "37PmyYwMGrH4uBR5V4DjCEvHGw4f2pdXW5u"
-        )
-    })
-})
-
-describe("Validate Account Address", () => {
-    const createMainnetAccount = () => {
-        return accountFactory({
-            chain: WalletTypes.Chain.Mainnet
-        }).address
-    }
-
-    const createTestnetAccount = () => {
-        return accountFactory({
-            chain: WalletTypes.Chain.Testnet
-        }).address
-    }
-
-    const addressMainnet = Array.from(new Array(20), () =>
-        createMainnetAccount()
-    )
-
-    const addressTestnet = Array.from(new Array(20), () =>
-        createTestnetAccount()
-    )
-    test.each(addressMainnet)(
-        "Test Validating Mainnet Account Address",
-        (addressMainnet) => {
-            const result = cryptoUtils.validateAddress(
-                addressMainnet,
-                WalletTypes.Chain.Mainnet
-            )
-            expect(result).toEqual(true)
-        }
-    )
-
-    test.each(addressTestnet)(
-        "Test Validating Testnet Account Address",
-        (addressTestnet) => {
-            const result = cryptoUtils.validateAddress(
-                addressTestnet,
-                WalletTypes.Chain.Mainnet
-            )
-            expect(result).toEqual(false)
-        }
-    )
-})
-
-describe("Create Signatures", () => {
-    const newAccountMainnet = () => {
-        return accountFactory({
-            chain: WalletTypes.Chain.Mainnet
-        })
-    }
-    const newAccountTestnet = () => {
-        return accountFactory({
-            chain: WalletTypes.Chain.Mainnet
-        })
-    }
-    const message = [
-        wasm.arrayToBase58(wasm.serializeString("Hello, Lunes Signature!")),
-        wasm.arrayToBase58(
-            wasm.serializeString(
-                "This is a new test for validate Signatures in Lunes Cryptography"
-            )
-        ),
-        wasm.arrayToBase58(
-            wasm.serializeString("Let's do some more tests just in case")
-        ),
-        wasm.arrayToBase58(
-            wasm.serializeString(
-                "One more to see if everything is working well"
-            )
-        ),
-        wasm.arrayToBase58(
-            wasm.serializeString(
-                "Lorem ipsum dolor sit amet, consectetur adipiscing elit. \
-        Maecenas turpis felis, gravida eget dapibus quis, molestie at mi. \
-        Phasellus quis mollis nulla. Nam euismod nec diam in viverra."
-            )
-        )
-    ]
-
-    test.each(message)(
-        "Test sign and validate signatures for Mainnet random Account with FastSignature function",
-        (message) => {
-            const w = newAccountMainnet()
-            const signature = cryptoUtils.fastSignature(w.privateKey, message)
-            const result = cryptoUtils.validateSignature(
-                w.publicKey,
-                message,
-                signature
-            )
-            expect(result).toEqual(true)
-        }
-    )
-    test.each(message)(
-        "Test sign and validate signatures for Testnet random Account with FastSignature function",
-        (message) => {
-            const w = newAccountTestnet()
-            const signature = cryptoUtils.fastSignature(w.privateKey, message)
-            const result = cryptoUtils.validateSignature(
-                w.publicKey,
-                message,
-                signature
-            )
-            expect(result).toEqual(true)
-        }
-    )
-    test.each(message)(
-        "Test sign and validate signatures for Mainnet random Account with FullSignature function",
-        (message) => {
-            const w = newAccountMainnet()
-            const signature = cryptoUtils.fullSignature(w.privateKey, message)
-            const result = cryptoUtils.validateSignature(
-                w.publicKey,
-                message,
-                signature
-            )
-            expect(result).toEqual(true)
-        }
-    )
-    test.each(message)(
-        "Test sign and validate signatures for Testnet random Account with FullSignature function",
-        (message) => {
-            const w = newAccountTestnet()
-            const signature = cryptoUtils.fullSignature(w.privateKey, message)
-            const result = cryptoUtils.validateSignature(
-                w.publicKey,
-                message,
-                signature
-            )
-            expect(result).toEqual(true)
-        }
-    )
-})

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es6",
-        "module": "commonjs",
-        "outDir": "./dist",
-        "strict": true,
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "noImplicitReturns": true,
-        "noFallthroughCasesInSwitch": true,
-        "esModuleInterop": true
-    },
-    "include": ["src/**/*"],
-    "exclude": ["node_modules", "**/*.test.ts"]
-}