chore: add update @fluent-wallet/account test

Author: iosh

package.json

@@ -58,6 +58,7 @@
     "test:integration": "cross-env NODE_OPTIONS=--experimental-vm-modules NODE_ENV=test node ./scripts/integration-test.js --no-cache  --config='./integration.jest.config.js'",
     "contract:compile": "bash ./scripts/solc.sh",
     "contract:watch": "watchexec --restart --on-busy-update queue -w ./contracts/ --debounce 500 yarn run contract:compile",
+    "test:vitest:unit": "vitest",
     "dev:chrome": "cross-env NODE_ENV=development cross-env TARGET_BROWSER=chrome webpack --config ./scripts/webpack.config.dev.mjs",
     "dev:firefox": "cross-env NODE_ENV=development cross-env TARGET_BROWSER=firefox webpack --config ./scripts/webpack.config.dev.mjs",
     "dev:edge": "cross-env NODE_ENV=development cross-env TARGET_BROWSER=edge webpack --config ./scripts/webpack.config.dev.mjs",
@@ -90,6 +91,7 @@
     "@types/js-string-escape": "^1",
     "@types/serve-static": "^1",
     "@types/webpack-bundle-analyzer": "^4",
+    "@vitest/coverage-v8": "2.0.5",
     "@yarnpkg/esbuild-plugin-pnp": "3.0.0-rc.2",
     "@yqrashawn/snowpack": "3.8.6-fix-6",
     "autoprefixer": "10.4.20",
@@ -152,6 +154,7 @@
     "stylelint-config-prettier": "^9.0.3",
     "stylelint-config-standard": "^26.0.0",
     "tailwindcss": "^3.1.1",
+    "vitest": "2.0.5",
     "wait-for-expect": "3.0.2",
     "web-ext": "7.0.0",
     "webpack": "5.93.0",

packages/account/index.js

@@ -2,29 +2,48 @@ import {getAddress as toChecksumAddress} from '@ethersproject/address'
 import {computeAddress} from '@ethersproject/transactions'
 import {Wallet} from '@ethersproject/wallet'
 import {randomInt, addHexPrefix} from '@fluent-wallet/utils'
-import {compL, threadFirst} from '@fluent-wallet/compose'
 import {
   NULL_HEX_ADDRESS,
   INTERNAL_CONTRACTS_HEX_ADDRESS,
   ADDRESS_TYPES,
 } from '@fluent-wallet/consts'
 
+/**
+ * @param {Object} options - An object that can contain a privateKey property.
+ * @param {string} options.pk - A hexadecimal string representing a private key.
+ * @return {Wallet} A new Wallet instance.
+ */
 export const create = ({pk} = {}) => {
   const kp = pk ? new Wallet(pk) : Wallet.createRandom()
   return kp
 }
+/**
+ *
+ * @param {string} address hex address
+ * @returns {string} checksum address
+ */
+export const toChecksum = address => toChecksumAddress(addHexPrefix(address)) // compL(addHexPrefix, toChecksumAddress)
 
-export const toChecksum = compL(addHexPrefix, toChecksumAddress)
-export const isChecksummed = compL(addHexPrefix, addr => {
+/**
+ *
+ * @param {string} addr
+ * @returns {boolean}
+ */
+export const isChecksummed = addr => {
   try {
-    return Boolean(toChecksumAddress(addr))
+    return Boolean(toChecksumAddress(addHexPrefix(addr)))
   } catch (err) {
     return false
   }
-})
-
+}
+/**
+ * @param {string} pk - private key
+ * @returns {Object}
+ * @property {string} address
+ * @property {string} privateKey
+ */
 export const fromPrivate = pk => ({
-  address: threadFirst(pk, addHexPrefix, computeAddress),
+  address: computeAddress(addHexPrefix(pk)), //threadFirst(pk, addHexPrefix, computeAddress),
   privateKey: addHexPrefix(pk),
 })
 
@@ -36,6 +55,15 @@ export const toContractAddress = address => {
   return address.replace(/^0x./, '0x8')
 }
 
+/**
+ * Generate a random hex address of the specified type.
+ *
+ * @param {string} [type] - The type of the address. Can be 'builtin', 'null', 'user', or 'contract'.
+ *    If not specified, a random type will be chosen.
+ * @param {boolean} [checksum=false] - Whether to return a checksummed address.
+ * @throws {Error} If the specified type is invalid.
+ * @returns {string} A random hex address.
+ */
 export const randomHexAddress = (type, checksum = false) => {
   if (type && !ADDRESS_TYPES.includes(type))
     throw new Error(`Invalid address type ${type}`)

packages/account/index.test.js

@@ -1,5 +1,5 @@
 // eslint-disable-next-line no-unused-vars
-import { expect, describe, test, it, jest, afterAll, afterEach, beforeAll, beforeEach } from '@jest/globals' // prettier-ignore
+import {describe, it, expect, test} from 'vitest'
 import {
   fromPrivate,
   toChecksum,
@@ -12,6 +12,11 @@ import {
   isBuiltInAddress,
   isCfxHexAddress,
   validateHexAddress,
+  isChecksummed,
+  randomAddressType,
+  randomCfxHexAddress,
+  randomPrivateKey,
+  validatePrivateKey,
 } from './'
 import {
   NULL_HEX_ADDRESS,
@@ -30,24 +35,24 @@ const checksumAddress = '0xED54a7C1d8634BB589f24Bb7F05a5554b36F9618'
 // const s = '0x129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66'
 // const v = '0x1b' // 27
 
-describe('account', function () {
-  describe('fromPrivate', function () {
-    it('should return the right address', async function () {
+describe('account', () => {
+  describe('fromPrivate', () => {
+    it('should return the right address', async () => {
       expect(fromPrivate(ecprivkey)).toEqual({
         address: checksumAddress,
         privateKey: ecprivkey,
       })
     })
   })
 
-  describe('toChecksum', function () {
-    it('should return the right checksum address', async function () {
+  describe('toChecksum', () => {
+    it('should return the right checksum address', async () => {
       expect(toChecksum(address)).toEqual(checksumAddress)
     })
   })
 
-  describe('create', function () {
-    it('should return the private key and address', async function () {
+  describe('create', () => {
+    it('should return the private key and address', async () => {
       const account = create()
       expect(account.address).toEqual(
         expect.stringMatching(/^0x[0-9a-fA-F]{40}$/),
@@ -56,28 +61,31 @@ describe('account', function () {
     })
   })
 
-  describe('randomHexAddress', function () {
-    it('should generate a random builtin address', async function () {
+  describe('randomHexAddress', () => {
+    it('should generate a random builtin address', async () => {
       expect(
         INTERNAL_CONTRACTS_HEX_ADDRESS.includes(randomHexAddress('builtin')),
       ).toBe(true)
     })
 
-    it('should generate the null address', async function () {
+    it('should generate the null address', async () => {
       expect(randomHexAddress('null')).toEqual(NULL_HEX_ADDRESS)
     })
 
-    it('should generate a contract address', async function () {
+    it('should generate a contract address', async () => {
       expect(randomHexAddress('contract').startsWith('0x8')).toBe(true)
     })
 
-    it('should generate a account address', async function () {
+    it('should generate a account address', async () => {
       expect(randomHexAddress('user').startsWith('0x1')).toBe(true)
     })
+    it('no args', () => {
+      expect(randomHexAddress()).toBeDefined()
+    })
   })
 
-  describe('checks', function () {
-    it('isHexAddress', function () {
+  describe('checks', () => {
+    it('isHexAddress', () => {
       expect(isHexAddress('0x0000000000000000000000000000000000000000')).toBe(
         true,
       )
@@ -86,13 +94,13 @@ describe('account', function () {
       )
     })
 
-    it('isNullHexAddress', function () {
+    it('isNullHexAddress', () => {
       expect(
         isNullHexAddress('0x0000000000000000000000000000000000000000'),
       ).toBe(true)
     })
 
-    it('isContractAddress', function () {
+    it('isContractAddress', () => {
       expect(
         isContractAddress('0x8000000000000000000000000000000000000000'),
       ).toBe(true)
@@ -104,7 +112,7 @@ describe('account', function () {
       ).toBe(false)
     })
 
-    it('isUserHexAddress', function () {
+    it('isUserHexAddress', () => {
       expect(
         isUserHexAddress('0x8000000000000000000000000000000000000000'),
       ).toBe(false)
@@ -116,7 +124,7 @@ describe('account', function () {
       ).toBe(false)
     })
 
-    it('isBuiltInAddress', function () {
+    it('isBuiltInAddress', () => {
       expect(
         isBuiltInAddress('0x0888000000000000000000000000000000000000'),
       ).toBe(true)
@@ -134,7 +142,7 @@ describe('account', function () {
       ).toBe(false)
     })
 
-    it('isCfxHexAddress', function () {
+    it('isCfxHexAddress', () => {
       expect(
         isCfxHexAddress('0x0888000000000000000000000000000000000000'),
       ).toBe(true)
@@ -155,7 +163,7 @@ describe('account', function () {
       ).toBe(false)
     })
 
-    it('validateHexAddress', function () {
+    it('validateHexAddress', () => {
       expect(
         validateHexAddress('0x0888000000000000000000000000000000000000'),
       ).toBe(true)
@@ -214,4 +222,39 @@ describe('account', function () {
       ).toThrow('Invalid address, must be a 0x-prefixed string')
     })
   })
+
+  describe('help methods', () => {
+    test('isChecksummed', () => {
+      expect(isChecksummed(checksumAddress)).toBe(true)
+      expect(isChecksummed('0x00000000000000000000000000000000000000011')).toBe(
+        false,
+      )
+    })
+    test('randomAddressType', () => {
+      expect(randomAddressType()).toBeDefined()
+    })
+
+    test('randomCfxHexAddress', () => {
+      const address = randomCfxHexAddress()
+      expect(
+        isBuiltInAddress(address) ||
+          isUserHexAddress(address) ||
+          isContractAddress(address) ||
+          isNullHexAddress(address),
+      ).toBe(true)
+    })
+
+    test('randomPrivateKey', () => {
+      const pk = randomPrivateKey()
+
+      expect(create({pk}).privateKey).toEqual(pk)
+    })
+
+    test('validatePrivateKey', () => {
+      const pk = randomPrivateKey()
+
+      expect(validatePrivateKey(pk)).toBe(true)
+      expect(validatePrivateKey('0x')).toBe(false)
+    })
+  })
 })

packages/account/package.json

@@ -7,7 +7,6 @@
     "@ethersproject/address": "5.6.1",
     "@ethersproject/transactions": "5.6.2",
     "@ethersproject/wallet": "5.6.2",
-    "@fluent-wallet/compose": "workspace:packages/compose",
     "@fluent-wallet/consts": "workspace:packages/consts",
     "@fluent-wallet/utils": "workspace:packages/utils",
     "elliptic": "6.5.4"

vite.config.ts

@@ -0,0 +1,4 @@
+import {defineConfig} from 'vitest/config'
+export default defineConfig({
+  test: {},
+})

vitest.workspace.ts

@@ -0,0 +1,3 @@
+import {defineWorkspace} from 'vitest/config'
+
+export default defineWorkspace(['packages/*'])