@ocap/wallet 1.19.0 → 1.19.2

package/esm/index.d.ts

@@ -0,0 +1,89 @@
+import { EncodingType, BytesType } from '@ocap/util';
+import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
+type KeyPairType<T extends BytesType = string> = {
+    sk?: T;
+    pk?: T;
+    address?: string;
+};
+export type SerializedWallet = {
+    type: DIDTypeStr;
+    pk: string;
+    sk: string;
+    address: string;
+};
+export interface WalletObject<T extends BytesType = string> {
+    type: DIDType;
+    secretKey: T;
+    publicKey: T;
+    address: string;
+    hash(data: BytesType, round?: number, encoding?: 'hex'): string;
+    hash(data: BytesType, round?: number, encoding?: 'base16'): string;
+    hash(data: BytesType, round?: number, encoding?: 'base58'): string;
+    hash(data: BytesType, round?: number, encoding?: 'base64'): string;
+    hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
+    hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
+    hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Buffer;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Uint8Array;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): BytesType;
+    verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
+    ethHash(data: string): string;
+    ethSign(data: string, hashBeforeSign?: boolean): string;
+    ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): boolean;
+    toJSON(): SerializedWallet;
+    /**
+     * @deprecated ES6: use `wallet.address` instead
+     */
+    toAddress(): string;
+}
+export declare const WalletType: typeof DidType;
+/**
+ * Generate an wallet instance that can be used to sign a message or verify a signature
+ */
+export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generate a wallet from secretKey
+ *
+ * @example
+ * const assert = require('assert');
+ * const { fromSecretKey } = require('@ocap/wallet');
+ *
+ * const sk =
+ *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+ * const sig =
+ *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+ *
+ * const wallet = fromSecretKey(sk, type);
+ * const message = 'data to sign';
+ * const signature = wallet.sign(message);
+ * assert.equal(signature, sig, "signature should match");
+ * assert.ok(wallet.verify(message, signature), "signature should be verified");
+ */
+export declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generate a wallet from publicKey
+ */
+export declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generate a wallet from address (did)
+ *
+ * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+ */
+export declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
+/**
+ * Generate a wallet by generating a random secretKey
+ */
+export declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generating a wallet from a serialized json presentation of another wallet
+ */
+export declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
+/**
+ * Check if an object is valid wallet object
+ */
+export declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
+export {};

package/esm/index.js

@@ -0,0 +1,161 @@
+import { toHex } from '@ocap/util';
+import { getSigner, getHasher } from '@ocap/mcrypto';
+import { toAddress, fromPublicKey as DIDFromPublicKey, toTypeInfo, DidType, } from '@arcblock/did';
+export const WalletType = DidType;
+/**
+ * Generate an wallet instance that can be used to sign a message or verify a signature
+ */
+export function Wallet(keyPair, t = 'default') {
+    const type = DidType(t);
+    const signer = getSigner(type.pk);
+    const hasher = getHasher(type.hash);
+    return {
+        type,
+        secretKey: keyPair.sk,
+        publicKey: keyPair.pk,
+        address: keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address,
+        // @ts-ignore
+        hash(data, round = 1, encoding = 'hex') {
+            return hasher(data, round, encoding);
+        },
+        // @ts-ignore
+        sign(data, hashBeforeSign = true, encoding = 'hex') {
+            if (!keyPair.sk) {
+                throw new Error('Cannot sign data without a secretKey');
+            }
+            if (hashBeforeSign) {
+                const hash = hasher(data, 1);
+                return signer.sign(hash, keyPair.sk, encoding);
+            }
+            return signer.sign(data, keyPair.sk, encoding);
+        },
+        // eslint-disable-next-line require-await
+        async verify(data, signature, hashBeforeVerify = true, extra) {
+            if (!keyPair.pk) {
+                throw new Error('Cannot verify data without a publicKey');
+            }
+            const hash = hashBeforeVerify ? hasher(data, 1) : data;
+            return signer.verify(hash, signature, keyPair.pk, extra);
+        },
+        ethHash(data) {
+            if (typeof signer.ethHash !== 'function') {
+                throw new Error('ethHash is not supported by signer');
+            }
+            return signer.ethHash(data);
+        },
+        ethSign(data, hashBeforeSign = true) {
+            if (!keyPair.sk) {
+                throw new Error('Cannot sign data without a secretKey');
+            }
+            if (typeof signer.ethHash !== 'function') {
+                throw new Error('ethSign is not supported by signer');
+            }
+            if (hashBeforeSign) {
+                return signer.ethSign(signer.ethHash(data), toHex(keyPair.sk));
+            }
+            return signer.ethSign(data, toHex(keyPair.sk));
+        },
+        ethVerify(data, signature, hashBeforeVerify = true) {
+            if (typeof signer.ethHash !== 'function') {
+                throw new Error('ethVerify is not supported by signer');
+            }
+            const hash = hashBeforeVerify ? signer.ethHash(data) : data;
+            return signer.ethRecover(hash, signature) === this.address;
+        },
+        // deprecated
+        toAddress() {
+            return keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address;
+        },
+        toJSON() {
+            return {
+                type: DidType.toJSON(type),
+                sk: toHex(keyPair.sk),
+                pk: toHex(keyPair.pk),
+                address: this.address,
+            };
+        },
+    };
+}
+/**
+ * Generate a wallet from secretKey
+ *
+ * @example
+ * const assert = require('assert');
+ * const { fromSecretKey } = require('@ocap/wallet');
+ *
+ * const sk =
+ *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+ * const sig =
+ *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+ *
+ * const wallet = fromSecretKey(sk, type);
+ * const message = 'data to sign';
+ * const signature = wallet.sign(message);
+ * assert.equal(signature, sig, "signature should match");
+ * assert.ok(wallet.verify(message, signature), "signature should be verified");
+ */
+export function fromSecretKey(sk, _type = 'default') {
+    const type = DidType(_type);
+    const keyPair = { sk, pk: getSigner(type.pk).getPublicKey(sk) };
+    return Wallet(keyPair, type);
+}
+/**
+ * Generate a wallet from publicKey
+ */
+export function fromPublicKey(pk, _type = 'default') {
+    return Wallet({ pk }, DidType(_type));
+}
+/**
+ * Generate a wallet from address (did)
+ *
+ * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+ */
+export function fromAddress(address) {
+    return Wallet({ address: toAddress(address) }, toTypeInfo(address));
+}
+/**
+ * Generate a wallet by generating a random secretKey
+ */
+export function fromRandom(_type = 'default') {
+    const type = DidType(_type);
+    const signer = getSigner(type.pk);
+    const keyPair = signer.genKeyPair();
+    return Wallet({ sk: keyPair.secretKey, pk: keyPair.publicKey }, type);
+}
+/**
+ * Generating a wallet from a serialized json presentation of another wallet
+ */
+export function fromJSON(json) {
+    const type = DidType.fromJSON(json.type);
+    // @ts-ignore
+    return Wallet(json, type);
+}
+/**
+ * Check if an object is valid wallet object
+ */
+export function isValid(wallet, canSign = true) {
+    if (!wallet || typeof wallet !== 'object') {
+        return false;
+    }
+    if (typeof wallet.verify !== 'function') {
+        return false;
+    }
+    if (typeof wallet.toAddress !== 'function') {
+        return false;
+    }
+    if (typeof wallet.toJSON !== 'function') {
+        return false;
+    }
+    if (!wallet.type || !wallet.publicKey) {
+        return false;
+    }
+    if (canSign) {
+        if (!wallet.secretKey) {
+            return false;
+        }
+        if (typeof wallet.sign !== 'function') {
+            return false;
+        }
+    }
+    return true;
+}

package/lib/index.d.ts

@@ -0,0 +1,89 @@
+import { EncodingType, BytesType } from '@ocap/util';
+import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
+type KeyPairType<T extends BytesType = string> = {
+    sk?: T;
+    pk?: T;
+    address?: string;
+};
+export type SerializedWallet = {
+    type: DIDTypeStr;
+    pk: string;
+    sk: string;
+    address: string;
+};
+export interface WalletObject<T extends BytesType = string> {
+    type: DIDType;
+    secretKey: T;
+    publicKey: T;
+    address: string;
+    hash(data: BytesType, round?: number, encoding?: 'hex'): string;
+    hash(data: BytesType, round?: number, encoding?: 'base16'): string;
+    hash(data: BytesType, round?: number, encoding?: 'base58'): string;
+    hash(data: BytesType, round?: number, encoding?: 'base64'): string;
+    hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
+    hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
+    hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): string;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Buffer;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Uint8Array;
+    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): BytesType;
+    verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
+    ethHash(data: string): string;
+    ethSign(data: string, hashBeforeSign?: boolean): string;
+    ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): boolean;
+    toJSON(): SerializedWallet;
+    /**
+     * @deprecated ES6: use `wallet.address` instead
+     */
+    toAddress(): string;
+}
+export declare const WalletType: typeof DidType;
+/**
+ * Generate an wallet instance that can be used to sign a message or verify a signature
+ */
+export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generate a wallet from secretKey
+ *
+ * @example
+ * const assert = require('assert');
+ * const { fromSecretKey } = require('@ocap/wallet');
+ *
+ * const sk =
+ *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+ * const sig =
+ *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+ *
+ * const wallet = fromSecretKey(sk, type);
+ * const message = 'data to sign';
+ * const signature = wallet.sign(message);
+ * assert.equal(signature, sig, "signature should match");
+ * assert.ok(wallet.verify(message, signature), "signature should be verified");
+ */
+export declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generate a wallet from publicKey
+ */
+export declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generate a wallet from address (did)
+ *
+ * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+ */
+export declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
+/**
+ * Generate a wallet by generating a random secretKey
+ */
+export declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
+/**
+ * Generating a wallet from a serialized json presentation of another wallet
+ */
+export declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
+/**
+ * Check if an object is valid wallet object
+ */
+export declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
+export {};

package/lib/index.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletType = void 0;
+exports.Wallet = Wallet;
+exports.fromSecretKey = fromSecretKey;
+exports.fromPublicKey = fromPublicKey;
+exports.fromAddress = fromAddress;
+exports.fromRandom = fromRandom;
+exports.fromJSON = fromJSON;
+exports.isValid = isValid;
+const util_1 = require("@ocap/util");
+const mcrypto_1 = require("@ocap/mcrypto");
+const did_1 = require("@arcblock/did");
+exports.WalletType = did_1.DidType;
+/**
+ * Generate an wallet instance that can be used to sign a message or verify a signature
+ */
+function Wallet(keyPair, t = 'default') {
+    const type = (0, did_1.DidType)(t);
+    const signer = (0, mcrypto_1.getSigner)(type.pk);
+    const hasher = (0, mcrypto_1.getHasher)(type.hash);
+    return {
+        type,
+        secretKey: keyPair.sk,
+        publicKey: keyPair.pk,
+        address: keyPair.pk ? (0, did_1.fromPublicKey)(keyPair.pk, type) : keyPair.address,
+        // @ts-ignore
+        hash(data, round = 1, encoding = 'hex') {
+            return hasher(data, round, encoding);
+        },
+        // @ts-ignore
+        sign(data, hashBeforeSign = true, encoding = 'hex') {
+            if (!keyPair.sk) {
+                throw new Error('Cannot sign data without a secretKey');
+            }
+            if (hashBeforeSign) {
+                const hash = hasher(data, 1);
+                return signer.sign(hash, keyPair.sk, encoding);
+            }
+            return signer.sign(data, keyPair.sk, encoding);
+        },
+        // eslint-disable-next-line require-await
+        async verify(data, signature, hashBeforeVerify = true, extra) {
+            if (!keyPair.pk) {
+                throw new Error('Cannot verify data without a publicKey');
+            }
+            const hash = hashBeforeVerify ? hasher(data, 1) : data;
+            return signer.verify(hash, signature, keyPair.pk, extra);
+        },
+        ethHash(data) {
+            if (typeof signer.ethHash !== 'function') {
+                throw new Error('ethHash is not supported by signer');
+            }
+            return signer.ethHash(data);
+        },
+        ethSign(data, hashBeforeSign = true) {
+            if (!keyPair.sk) {
+                throw new Error('Cannot sign data without a secretKey');
+            }
+            if (typeof signer.ethHash !== 'function') {
+                throw new Error('ethSign is not supported by signer');
+            }
+            if (hashBeforeSign) {
+                return signer.ethSign(signer.ethHash(data), (0, util_1.toHex)(keyPair.sk));
+            }
+            return signer.ethSign(data, (0, util_1.toHex)(keyPair.sk));
+        },
+        ethVerify(data, signature, hashBeforeVerify = true) {
+            if (typeof signer.ethHash !== 'function') {
+                throw new Error('ethVerify is not supported by signer');
+            }
+            const hash = hashBeforeVerify ? signer.ethHash(data) : data;
+            return signer.ethRecover(hash, signature) === this.address;
+        },
+        // deprecated
+        toAddress() {
+            return keyPair.pk ? (0, did_1.fromPublicKey)(keyPair.pk, type) : keyPair.address;
+        },
+        toJSON() {
+            return {
+                type: did_1.DidType.toJSON(type),
+                sk: (0, util_1.toHex)(keyPair.sk),
+                pk: (0, util_1.toHex)(keyPair.pk),
+                address: this.address,
+            };
+        },
+    };
+}
+/**
+ * Generate a wallet from secretKey
+ *
+ * @example
+ * const assert = require('assert');
+ * const { fromSecretKey } = require('@ocap/wallet');
+ *
+ * const sk =
+ *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+ * const sig =
+ *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+ *
+ * const wallet = fromSecretKey(sk, type);
+ * const message = 'data to sign';
+ * const signature = wallet.sign(message);
+ * assert.equal(signature, sig, "signature should match");
+ * assert.ok(wallet.verify(message, signature), "signature should be verified");
+ */
+function fromSecretKey(sk, _type = 'default') {
+    const type = (0, did_1.DidType)(_type);
+    const keyPair = { sk, pk: (0, mcrypto_1.getSigner)(type.pk).getPublicKey(sk) };
+    return Wallet(keyPair, type);
+}
+/**
+ * Generate a wallet from publicKey
+ */
+function fromPublicKey(pk, _type = 'default') {
+    return Wallet({ pk }, (0, did_1.DidType)(_type));
+}
+/**
+ * Generate a wallet from address (did)
+ *
+ * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+ */
+function fromAddress(address) {
+    return Wallet({ address: (0, did_1.toAddress)(address) }, (0, did_1.toTypeInfo)(address));
+}
+/**
+ * Generate a wallet by generating a random secretKey
+ */
+function fromRandom(_type = 'default') {
+    const type = (0, did_1.DidType)(_type);
+    const signer = (0, mcrypto_1.getSigner)(type.pk);
+    const keyPair = signer.genKeyPair();
+    return Wallet({ sk: keyPair.secretKey, pk: keyPair.publicKey }, type);
+}
+/**
+ * Generating a wallet from a serialized json presentation of another wallet
+ */
+function fromJSON(json) {
+    const type = did_1.DidType.fromJSON(json.type);
+    // @ts-ignore
+    return Wallet(json, type);
+}
+/**
+ * Check if an object is valid wallet object
+ */
+function isValid(wallet, canSign = true) {
+    if (!wallet || typeof wallet !== 'object') {
+        return false;
+    }
+    if (typeof wallet.verify !== 'function') {
+        return false;
+    }
+    if (typeof wallet.toAddress !== 'function') {
+        return false;
+    }
+    if (typeof wallet.toJSON !== 'function') {
+        return false;
+    }
+    if (!wallet.type || !wallet.publicKey) {
+        return false;
+    }
+    if (canSign) {
+        if (!wallet.secretKey) {
+            return false;
+        }
+        if (typeof wallet.sign !== 'function') {
+            return false;
+        }
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/wallet",
-  "version": "1.19.0",
+  "version": "1.19.2",
   "description": "Utility function to create and use an forge compatible crypto wallet",
   "keywords": [
     "crypto",
@@ -21,15 +21,11 @@
   "homepage": "https://github.com/ArcBlock/blockchain/tree/master/core/forge-wallet",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
-  "module": "./lib/index.js",
-  "types": "./esm/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./esm/index.js",
-      "require": "./lib/index.js",
-      "default": "./esm/index.js"
-    }
-  },
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib",
+    "esm"
+  ],
   "devDependencies": {
     "@arcblock/eslint-config-ts": "0.3.3",
     "@types/jest": "^29.5.13",
@@ -59,9 +55,9 @@
     "url": "https://github.com/ArcBlock/blockchain/issues"
   },
   "dependencies": {
-    "@arcblock/did": "1.19.0",
-    "@ocap/mcrypto": "1.19.0",
-    "@ocap/util": "1.19.0"
+    "@arcblock/did": "1.19.2",
+    "@ocap/mcrypto": "1.19.2",
+    "@ocap/util": "1.19.2"
   },
-  "gitHead": "1b6fac03988fb18507c8ef4c21de282762005f87"
+  "gitHead": "6fd339211e6500fbb5cac6401a25130e629345b9"
 }

package/.eslintrc.js

@@ -1,12 +0,0 @@
-const path = require('path');
-
-module.exports = {
-  root: true,
-  extends: ['@arcblock/eslint-config-ts/base'],
-  parserOptions: {
-    project: path.resolve(__dirname, 'tsconfig.eslint.json'),
-  },
-  rules: {
-    '@typescript-eslint/comma-dangle': 'off',
-  },
-};

package/docs/README.md

@@ -1,186 +0,0 @@
-## Modules
-
-<dl>
-<dt><a href="#module_@ocap/wallet">@ocap/wallet</a></dt>
-<dd><p>This module wraps common utility functions to help developers manipulate crypto wallets</p>
-</dd>
-</dl>
-
-## Typedefs
-
-<dl>
-<dt><a href="#WalletObject">WalletObject</a></dt>
-<dd></dd>
-</dl>
-
-## @ocap/wallet
-
-This module wraps common utility functions to help developers manipulate crypto wallets
-
-**Requires**: `module:@ocap/mcrypto`, `module:@arcblock/did`\
-**Example**
-
-```js
-yarn add @ocap/wallet
-```
-
-*   [Wallet(keyPair, \[type\])](#Wallet) ⇒ [`WalletObject`](#WalletObject)
-*   [fromSecretKey(sk, \[type\])](#fromSecretKey) ⇒ [`WalletObject`](#WalletObject)
-*   [fromPublicKey(pk, \[type\])](#fromPublicKey) ⇒ [`WalletObject`](#WalletObject)
-*   [fromAddress(address)](#fromAddress) ⇒ [`WalletObject`](#WalletObject)
-*   [fromRandom(\[type\])](#fromRandom) ⇒ [`WalletObject`](#WalletObject)
-*   [fromJSON(json)](#fromJSON) ⇒ [`WalletObject`](#WalletObject)
-*   [isValid(wallet, canSign)](#isValid)
-
-### Wallet(keyPair, \[type]) ⇒ [`WalletObject`](#WalletObject)
-
-Generate an wallet instance that can be used to sign a message or verify a signature
-
-**Kind**: static method\
-**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
-**Access**: public
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| keyPair | `object` |  | the key pair |
-| keyPair.sk | `string` |  | the secretKey |
-| keyPair.pk | `string` |  | the wallet publicKey |
-| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
-
-### fromSecretKey(sk, \[type]) ⇒ [`WalletObject`](#WalletObject)
-
-Generate a wallet from secretKey
-
-**Kind**: static method\
-**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
-**Access**: public
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| sk | `string` |  | the secret key, `hex encoded string` |
-| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
-
-**Example**
-
-```js
-const assert = require('assert');
-const { fromSecretKey } = require('@ocap/wallet');
-
-const sk =
-  '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
-const sig =
-  '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
-
-const wallet = fromSecretKey(sk, type);
-const message = 'data to sign';
-const signature = wallet.sign(message);
-assert.equal(signature, sig, "signature should match");
-assert.ok(wallet.verify(message, signature), "signature should be verified");
-```
-
-### fromPublicKey(pk, \[type]) ⇒ [`WalletObject`](#WalletObject)
-
-Generate a wallet from publicKey
-
-**Kind**: static method\
-**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
-**Access**: public
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| pk | `string` |  | the public key, `hex encoded string` |
-| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
-
-### fromAddress(address) ⇒ [`WalletObject`](#WalletObject)
-
-Generate a wallet from address (did)
-
-Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
-
-**Kind**: static method\
-**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
-**Access**: public
-
-| Param | Type | Description |
-| --- | --- | --- |
-| address | `string` | the wallet address |
-
-**Example**
-
-```js
-const assert = require('assert');
-const { fromAddress } = require('@ocap/wallet');
-
-const address = 'zNKtCNqYWLYWYW3gWRA1vnRykfCBZYHZvzKr';
-const wallet = fromAddress(address);
-console.log(wallet.toJSON());
-```
-
-### fromRandom(\[type]) ⇒ [`WalletObject`](#WalletObject)
-
-Generate a wallet by generating a random secretKey
-
-**Kind**: static method\
-**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
-**Access**: public
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
-
-**Example**
-
-```js
-const { fromRandom } = require('@ocap/wallet');
-const wallet = fromRandom();
-// Do something with wallet
-```
-
-### fromJSON(json) ⇒ [`WalletObject`](#WalletObject)
-
-Generating a wallet from a serialized json presentation of another wallet
-
-**Kind**: static method\
-**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
-**Access**: public
-
-| Param | Type | Description |
-| --- | --- | --- |
-| json | `object` | json presentation of a wallet |
-
-**Example**
-
-```js
-const { fromJSON, fromRandom } = require('@ocap/wallet');
-const wallet = fromRandom();
-const wallet2 = fromJSON(wallet.toJSON());
-// wallet2 is identical to wallet
-```
-
-### isValid(wallet, canSign)
-
-Check if an object is valid wallet object
-
-**Kind**: static method\
-**Access**: public
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| wallet | `object` |  |  |
-| canSign | `boolean` | `true` | should the wallet support sign |
-
-## WalletObject
-
-**Kind**: global typedef\
-**Access**: public\
-**Properties**
-
-| Name | Type | Description |
-| --- | --- | --- |
-| type | `DidType` | Indicates the wallet type |
-| secretKey | `secretKey` | Wallet secretKey |
-| publicKey | `publicKey` | Wallet publicKey |
-| sign | `function` | Sign `data`, data is hashed using the `HashType` defined in type before signing |
-| verify | `function` | Verify `signature`, data is hashed using the `HashType` defined in type before verifying |
-| toAddress | `function` | Get wallet address without `did:abt:` prefix |
-| toJSON | `function` | Serialize wallet to json object, checkout [fromJSON](fromJSON) for deserialisation |

package/jest.config.js

@@ -1,7 +0,0 @@
-const base = require('../../jest.config.base');
-
-module.exports = {
-  ...base,
-  preset: 'ts-jest',
-  collectCoverageFrom: ['<rootDir>/core/wallet/src/*.ts', '<rootDir>/core/wallet/src/**/*.ts'],
-};

package/src/index.ts

@@ -1,235 +0,0 @@
-import { toHex, EncodingType, BytesType } from '@ocap/util';
-import { getSigner, getHasher } from '@ocap/mcrypto';
-import {
-  toAddress,
-  fromPublicKey as DIDFromPublicKey,
-  toTypeInfo,
-  DidType,
-  DIDType,
-  DIDTypeStr,
-  DIDTypeArg,
-} from '@arcblock/did';
-
-type KeyPairType<T extends BytesType = string> = {
-  sk?: T;
-  pk?: T;
-  address?: string;
-};
-
-export type SerializedWallet = {
-  type: DIDTypeStr;
-  pk: string;
-  sk: string;
-  address: string;
-};
-
-export interface WalletObject<T extends BytesType = string> {
-  type: DIDType;
-  secretKey: T;
-  publicKey: T;
-  address: string;
-
-  hash(data: BytesType, round?: number, encoding?: 'hex'): string;
-  hash(data: BytesType, round?: number, encoding?: 'base16'): string;
-  hash(data: BytesType, round?: number, encoding?: 'base58'): string;
-  hash(data: BytesType, round?: number, encoding?: 'base64'): string;
-  hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
-  hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
-  hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
-
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Buffer;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Uint8Array;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): BytesType;
-
-  verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
-
-  ethHash(data: string): string;
-  ethSign(data: string, hashBeforeSign?: boolean): string;
-  ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): boolean;
-
-  toJSON(): SerializedWallet;
-
-  /**
-   * @deprecated ES6: use `wallet.address` instead
-   */
-  toAddress(): string;
-}
-
-export const WalletType = DidType;
-
-/**
- * Generate an wallet instance that can be used to sign a message or verify a signature
- */
-export function Wallet<T extends BytesType = string>(
-  keyPair: KeyPairType<T>,
-  t: DIDTypeArg = 'default'
-): WalletObject<T> {
-  const type = DidType(t);
-  const signer = getSigner(type.pk);
-  const hasher = getHasher(type.hash);
-  return {
-    type,
-    secretKey: keyPair.sk,
-    publicKey: keyPair.pk,
-    address: keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address,
-
-    // @ts-ignore
-    hash(data: BytesType, round = 1, encoding: EncodingType = 'hex'): BytesType {
-      return hasher(data, round, encoding);
-    },
-
-    // @ts-ignore
-    sign(data: BytesType, hashBeforeSign = true, encoding: EncodingType = 'hex'): BytesType {
-      if (!keyPair.sk) {
-        throw new Error('Cannot sign data without a secretKey');
-      }
-      if (hashBeforeSign) {
-        const hash = hasher(data, 1);
-        return signer.sign(hash, keyPair.sk, encoding);
-      }
-      return signer.sign(data, keyPair.sk, encoding);
-    },
-
-    // eslint-disable-next-line require-await
-    async verify(data: BytesType, signature: BytesType, hashBeforeVerify = true, extra?: any): Promise<boolean> {
-      if (!keyPair.pk) {
-        throw new Error('Cannot verify data without a publicKey');
-      }
-      const hash = hashBeforeVerify ? hasher(data, 1) : data;
-      return signer.verify(hash, signature, keyPair.pk, extra);
-    },
-
-    ethHash(data: string): string {
-      if (typeof signer.ethHash !== 'function') {
-        throw new Error('ethHash is not supported by signer');
-      }
-      return signer.ethHash(data);
-    },
-    ethSign(data: string, hashBeforeSign = true): string {
-      if (!keyPair.sk) {
-        throw new Error('Cannot sign data without a secretKey');
-      }
-      if (typeof signer.ethHash !== 'function') {
-        throw new Error('ethSign is not supported by signer');
-      }
-      if (hashBeforeSign) {
-        return signer.ethSign(signer.ethHash(data), toHex(keyPair.sk));
-      }
-      return signer.ethSign(data, toHex(keyPair.sk));
-    },
-    ethVerify(data: string, signature: string, hashBeforeVerify = true): boolean {
-      if (typeof signer.ethHash !== 'function') {
-        throw new Error('ethVerify is not supported by signer');
-      }
-      const hash = hashBeforeVerify ? signer.ethHash(data) : data;
-      return signer.ethRecover(hash, signature) === this.address;
-    },
-
-    // deprecated
-    toAddress(): string {
-      return keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address;
-    },
-
-    toJSON(): SerializedWallet {
-      return {
-        type: DidType.toJSON(type),
-        sk: toHex(keyPair.sk),
-        pk: toHex(keyPair.pk),
-        address: this.address,
-      };
-    },
-  };
-}
-
-/**
- * Generate a wallet from secretKey
- *
- * @example
- * const assert = require('assert');
- * const { fromSecretKey } = require('@ocap/wallet');
- *
- * const sk =
- *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
- * const sig =
- *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
- *
- * const wallet = fromSecretKey(sk, type);
- * const message = 'data to sign';
- * const signature = wallet.sign(message);
- * assert.equal(signature, sig, "signature should match");
- * assert.ok(wallet.verify(message, signature), "signature should be verified");
- */
-export function fromSecretKey<T extends BytesType = string>(sk: T, _type: DIDTypeArg = 'default'): WalletObject<T> {
-  const type = DidType(_type);
-  const keyPair = { sk, pk: getSigner(type.pk).getPublicKey(sk) as T };
-  return Wallet<T>(keyPair, type);
-}
-
-/**
- * Generate a wallet from publicKey
- */
-export function fromPublicKey<T extends BytesType = string>(pk: T, _type: DIDTypeArg = 'default'): WalletObject<T> {
-  return Wallet<T>({ pk }, DidType(_type));
-}
-
-/**
- * Generate a wallet from address (did)
- *
- * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
- */
-export function fromAddress<T extends BytesType = string>(address: string): WalletObject<T> {
-  return Wallet<T>({ address: toAddress(address) }, toTypeInfo(address));
-}
-
-/**
- * Generate a wallet by generating a random secretKey
- */
-export function fromRandom<T extends BytesType = string>(_type: DIDTypeArg = 'default'): WalletObject<T> {
-  const type = DidType(_type);
-  const signer = getSigner(type.pk);
-  const keyPair = signer.genKeyPair();
-  return Wallet<T>({ sk: keyPair.secretKey as T, pk: keyPair.publicKey as T }, type);
-}
-
-/**
- * Generating a wallet from a serialized json presentation of another wallet
- */
-export function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T> {
-  const type = DidType.fromJSON(json.type);
-  // @ts-ignore
-  return Wallet<T>(json, type);
-}
-
-/**
- * Check if an object is valid wallet object
- */
-export function isValid(wallet: WalletObject, canSign = true): boolean {
-  if (!wallet || typeof wallet !== 'object') {
-    return false;
-  }
-  if (typeof wallet.verify !== 'function') {
-    return false;
-  }
-  if (typeof wallet.toAddress !== 'function') {
-    return false;
-  }
-  if (typeof wallet.toJSON !== 'function') {
-    return false;
-  }
-  if (!wallet.type || !wallet.publicKey) {
-    return false;
-  }
-  if (canSign) {
-    if (!wallet.secretKey) {
-      return false;
-    }
-    if (typeof wallet.sign !== 'function') {
-      return false;
-    }
-  }
-  return true;
-}

package/tests/index.spec.ts

@@ -1,116 +0,0 @@
-import { types } from '@ocap/mcrypto';
-import { fromBase64 } from '@ocap/util';
-import { fromRandom, fromPublicKey, fromSecretKey, fromJSON, fromAddress, isValid } from '../src/index';
-
-const sk =
-  '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
-const pk = '0xE4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
-const appId = 'zNKtCNqYWLYWYW3gWRA1vnRykfCBZYHZvzKr';
-const sig =
-  '0x8122c608f61b04f6b574f005dc8e0463d393a7fb50e0426bca587b20778a8a9f6376bab87bc3983b0a5f1c9581f6d94162317c715a3c1c0f086be1e514399109';
-const type = {
-  role: types.RoleType.ROLE_APPLICATION,
-  pk: types.KeyType.ED25519,
-  hash: types.HashType.SHA3,
-  address: types.EncodingType.BASE58,
-};
-describe('#Wallet', () => {
-  test('should have basic functions', () => {
-    expect(typeof fromPublicKey).toEqual('function');
-    expect(typeof fromSecretKey).toEqual('function');
-    expect(typeof fromJSON).toEqual('function');
-  });
-
-  test('should serialize to json as expected', () => {
-    const wallet = fromPublicKey(pk, type);
-    const json = wallet.toJSON();
-    expect(json.address).toEqual(appId);
-    const wallet2 = fromJSON(json);
-    expect(wallet2.address).toEqual(appId);
-    expect(wallet2.address).toEqual(appId);
-  });
-
-  test('should throw error when sign without sk', () => {
-    const wallet = fromPublicKey(pk, type);
-    const hash = wallet.hash('abc');
-    expect(hash).toEqual('0x3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532');
-    try {
-      wallet.sign('data to sign');
-    } catch (err) {
-      expect(err).toBeTruthy();
-    }
-  });
-
-  test('should sign when sk is provided', async () => {
-    const wallet = fromSecretKey(sk, type);
-    const hash = wallet.hash('abc');
-    expect(hash).toEqual('0x3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532');
-    const message = 'data to sign';
-    const signature = wallet.sign(message);
-    expect(signature).toEqual(sig);
-    expect(await wallet.verify(message, signature)).toEqual(true);
-    expect(() => fromSecretKey('abc')).toThrow();
-  });
-
-  test('should gen type from address', () => {
-    const wallet = fromAddress(appId);
-    expect(wallet.type.pk).toEqual(type.pk);
-    expect(wallet.type.hash).toEqual(type.hash);
-    expect(wallet.type.role).toEqual(type.role);
-  });
-
-  test('should detect invalid wallets', () => {
-    const wallet = fromRandom();
-    expect(isValid(wallet)).toEqual(true);
-    const wallet2 = fromPublicKey(pk, type);
-    expect(isValid(wallet2, false)).toEqual(true);
-  });
-
-  test('should generate base58 address', () => {
-    const wallet = fromRandom();
-    expect(wallet.toAddress().startsWith('z')).toBeTruthy();
-    expect(wallet.address.startsWith('z')).toBeTruthy();
-    expect(() => wallet.ethHash('abc')).toThrow();
-    expect(() => wallet.ethSign('abc')).toThrow();
-  });
-
-  test('should generate base16 address', () => {
-    const wallet = fromRandom('eth');
-    expect(wallet.address.startsWith('0x')).toBeTruthy();
-  });
-
-  test('should work with ethereum', async () => {
-    // eslint-disable-next-line
-    const sk = '0xfe51dc1dfe30e2f4b06f7941bdfe0341704c10e28d28e4ecd7871f8f0204fa33';
-    const address = '0x5547a73ed3c2Ad599114866fA1d5E8a02147D1C9';
-    const data = '0xef56b956483ebe2fa8ed6c35c8b884d940d57fdf535a70a2df245661c9cf42e4';
-    // eslint-disable-next-line
-    const sig = '0x242ad32e16c38307e2909600cb641da17734121d9d50df93b6240db40ad3fc2d562f3e41cc6409730cbb81c5bc90a914f24baf0d3537a7db8334dc67ed2000fe1c'; // prettier-ignore
-    const wallet = fromSecretKey(sk, 'eth');
-    expect(wallet.address).toEqual(address);
-    expect(wallet.ethSign(data)).toEqual(sig);
-    expect(wallet.ethHash(data)).toEqual('0x9f5dc66bef3e8053b02c4cb6a8504cb4d7e48862245a4d34fc69bc615080d276');
-    expect(await wallet.ethVerify(data, sig)).toEqual(true);
-    expect(() => fromSecretKey('abc', 'eth')).toThrow();
-  });
-
-  test('should work with passkey', async () => {
-    const publicKey = fromBase64(
-      'pQECAyYgASFYIA3GyM4rSxM_HyV52QTRwGJOdkXurky3cwTLvb_gKSF-Ilggpd0fhMlPdxHBl45_eJxqywCRl-a4IDpeFa4pcfmrxuM'
-    );
-
-    const wallet = fromPublicKey(publicKey, 'passkey');
-    expect(wallet.address).toEqual('z3i165rPumFgyQZpZ1W3VLEYBPuV2xSCAjoqo');
-
-    const challenge = '0x7E093B990CB41A97990657D6AD688BD4E28267C9FCC0A36BC15D241D5D302CEF';
-    const response = {
-      authenticatorData: 'u_rJjitfFaLnT_p0uECHZ0CSuRQE7psYSUxv2p-nql0dAAAAAA',
-      clientDataJSON:
-        'eyJ0eXBlIjoid2ViYXV0aG4uZ2V0IiwiY2hhbGxlbmdlIjoiZmdrN21ReTBHcGVaQmxmV3JXaUwxT0tDWjhuOHdLTnJ3VjBrSFYwd0xPOCIsIm9yaWdpbiI6Imh0dHBzOi8vYmJxYXhlN2lhZGZpbWRkY2c0cmZycHRmdXp4bW12NWI2dnBudXB1bmk0NC5kaWQuYWJ0bmV0LmlvIiwiY3Jvc3NPcmlnaW4iOmZhbHNlfQ',
-      signature: 'MEUCIQCo51Gg_3UrSotxrguG92iXcuSbW5fNZqcSsHS8zlZbdAIgEmaBD0cQeiML3Mr60HSPP176EyqNvqfTdEV1oGWhQ-o',
-    };
-
-    const verified = await wallet.verify(challenge, response.signature, false, JSON.stringify(response));
-    expect(verified).toEqual(true);
-  });
-});

package/tsconfig.cjs.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": ["src"],
-  "exclude": ["node_modules", "tests"],
-  "compilerOptions": {
-    "module": "commonjs",
-    "outDir": "lib"
-  }
-}

package/tsconfig.eslint.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": ["src", "tests", ".eslintrc.js", "jest.config.js"]
-}

package/tsconfig.esm.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": ["src"],
-  "exclude": ["node_modules", "tests"],
-  "compilerOptions": {
-    "module": "esnext",
-    "outDir": "esm"
-  }
-}