@ocap/sdk 1.16.16 → 1.17.1

package/index.d.ts

@@ -1,4 +1,209 @@
-import * as bnJs from 'bn.js';
+/// <reference types="node" />
+import rightPad from 'lodash/padEnd';
+import leftPad from 'lodash/padStart';
+import BN from 'bn.js';
+export declare type BytesType = string | Buffer | Uint8Array;
+export declare type EncodingType = 'hex' | 'base16' | 'base58' | 'base64' | 'Uint8Array' | 'buffer';
+export declare type KeyPairType = {
+  publicKey: BytesType;
+  secretKey: BytesType;
+};
+export { BN, leftPad, rightPad };
+/**
+ * Returns a BN object, converts a number value to a BN
+ * @param {String|Number|Object} `arg` input a string number, hex string number, number, BigNumber or BN object
+ * @return {Object} `output` BN object of the number
+ * @throws if the argument is not an array, object that isn't a bignumber, not a string number or number
+ */
+export declare const numberToBN: (arg: string | number | BN) => BN;
+/**
+ * Returns a `boolean` on whether or not the `string` starts with '0x'
+ *
+ * @public
+ * @static
+ * @param {String} str the string input value
+ * @return {Boolean} a boolean if it is or is not hex prefixed
+ * @throws if the str input is not a string
+ */
+export declare const isHexPrefixed: (str: string) => boolean;
+/**
+ * Removes '0x' from a given `String` if present
+ *
+ * @public
+ * @static
+ * @param {String} str the string value
+ * @return {String|Optional} a string by pass if necessary
+ */
+export declare const stripHexPrefix: (str: $TSFixMe) => any;
+/**
+ * Returns true if object is BN, otherwise false
+ *
+ * @public
+ * @static
+ * @method isBN
+ * @param {Object} object
+ * @returns {Boolean}
+ */
+export declare const isBN: (object: $TSFixMe) => boolean;
+/**
+ * Returns true if object is BigNumber, otherwise false
+ *
+ * @public
+ * @static
+ * @method isBigNumber
+ * @param {Object} object
+ * @returns {Boolean}
+ */
+export declare const isBigNumber: (object: $TSFixMe) => boolean;
+/**
+ * Check if string is HEX, requires a 0x in front
+ *
+ * @public
+ * @static
+ * @method isHexStrict
+ * @param {String} hex to be checked
+ * @returns {Boolean}
+ */
+export declare const isHexStrict: (hex: string) => boolean;
+/**
+ * Check if string is HEX
+ *
+ * @public
+ * @static
+ * @method isHex
+ * @param {String} hex to be checked
+ * @returns {Boolean}
+ */
+export declare const isHex: (hex: string) => boolean;
+/**
+ * Takes an input and transforms it into an BN
+ *
+ * @public
+ * @static
+ * @method toBN
+ * @param {Number|String|BN} num, string, HEX string or BN
+ * @returns {BN} BN
+ */
+export declare const toBN: (num: number | string | BN, base?: number | 'hex') => BN;
+/**
+ * Should be called to get hex representation (prefixed by 0x) of utf8 string
+ *
+ * @public
+ * @static
+ * @method utf8ToHex
+ * @param {String} str
+ * @returns {String} hex representation of input string
+ */
+export declare const utf8ToHex: (str: string) => string;
+/**
+ * Should be called to get utf8 from it's hex representation
+ *
+ * @public
+ * @static
+ * @method hexToUtf8
+ * @param {String} hex
+ * @returns {String} ascii string representation of hex value
+ */
+export declare const hexToUtf8: (hex: string) => string;
+/**
+ * Converts value to number representation
+ *
+ * @public
+ * @static
+ * @method hexToNumber
+ * @param {String|Number|BN} value
+ * @returns {Number}
+ */
+export declare const hexToNumber: (value: string | number | BN) => string | number | BN;
+/**
+ * Converts value to hex representation
+ *
+ * @public
+ * @static
+ * @method numberToHex
+ * @param {String|Number|BN} value
+ * @returns {String}
+ */
+export declare const numberToHex: (value: $TSFixMe) => string;
+/**
+ * Convert a byte array to a hex string
+ * Note: Implementation from crypto-js
+ *
+ * @public
+ * @static
+ * @method bytesToHex
+ * @param {Array} bytes
+ * @returns {String} the hex string
+ */
+export declare const bytesToHex: (bytes: $TSFixMe) => string;
+/**
+ * Convert a hex string to a byte array
+ * Note: Implementation from crypto-js
+ *
+ * @public
+ * @static
+ * @method hexToBytes
+ * @param {String} hex
+ * @returns {Array} the byte array
+ */
+export declare const hexToBytes: (hex: $TSFixMe) => number[];
+/**
+ * Auto converts any given value into it's hex representation.
+ * And even stringify objects before.
+ *
+ * @public
+ * @static
+ * @method toHex
+ * @param {String|Number|BN|Object|TypedArray|Buffer} value
+ * @param {Boolean} returnType
+ * @returns {String}
+ */
+export declare const toHex: (
+  value:
+    | string
+    | number
+    | boolean
+    | BN
+    | Uint8Array
+    | Buffer
+    | (
+        | number
+        | {
+            test: string;
+          }
+      )[]
+    | {
+        test: string;
+      },
+  returnType?: boolean
+) => string;
+export declare const numberToString: (arg: $TSFixMe) => any;
+/**
+ * Format a big number to human readable number, such as 1_0000_0000_0000_000 => 1 Token
+ *
+ * @public
+ * @static
+ * @method fromUnitToToken
+ * @param {string|number} input
+ * @param {number} [decimal=18]
+ * @param {object} [optionsInput=undefined]
+ * @returns {string}
+ */
+export declare const fromUnitToToken: (
+  input: string | number | BN,
+  decimal?: number,
+  optionsInput?: $TSFixMe
+) => string;
+/**
+ * Convert human readable token number to big number instance
+ *
+ * @public
+ * @static
+ * @param {string} input
+ * @param {number} [decimal=18]
+ * @returns {BN}
+ */
+export declare const fromTokenToUnit: (input: string | number, decimal?: number) => BN;
 /**
  * Validates if a value is an Uint8Array.
  *
@@ -7,7 +212,24 @@ import * as bnJs from 'bn.js';
  * @param {*} value - value to validate
  * @returns {Boolean} boolean indicating if a value is an Uint8Array
  */
-declare function isUint8Array(value: any): boolean;
+export declare function isUint8Array(value: $TSFixMe): boolean;
+/**
+ * Generate a random UUID
+ *
+ * @public
+ * @static
+ * @returns {string} Generated uuid
+ */
+export declare function UUID(): string;
+/**
+ * Check if a string is valid UUID
+ *
+ * @public
+ * @static
+ * @param {string} str
+ * @returns {boolean}
+ */
+export declare function isUUID(str: string): boolean;
 /**
  * Convert input to Uint8Array on best effort, base64 node supported
  *
@@ -17,7 +239,7 @@ declare function isUint8Array(value: any): boolean;
  * @returns {Uint8Array}
  * @throws {Error}
  */
-declare function toUint8Array(v: any): Uint8Array;
+export declare function toUint8Array(v: $TSFixMe): Uint8Array;
 /**
  * Convert input to Buffer on best effort, base64 not supported
  *
@@ -27,7 +249,7 @@ declare function toUint8Array(v: any): Uint8Array;
  * @returns {buffer}
  * @throws {Error}
  */
-declare function toBuffer(v: any): any;
+export declare function toBuffer(v: $TSFixMe): Buffer;
 /**
  * Convert input to base58btc format on best effort
  *
@@ -37,7 +259,7 @@ declare function toBuffer(v: any): any;
  * @returns {string}
  * @throws {Error}
  */
-declare function toBase58(v: any): string;
+export declare function toBase58(v: $TSFixMe): string;
 /**
  * Decode base58 string
  *
@@ -46,7 +268,7 @@ declare function toBase58(v: any): string;
  * @param {string} v
  * @returns {buffer}
  */
-declare function fromBase58(v: string): any;
+export declare function fromBase58(v: string): Buffer;
 /**
  * Convert input to base64 format
  *
@@ -57,7 +279,7 @@ declare function fromBase58(v: string): any;
  * @returns {string}
  * @throws {Error}
  */
-declare function toBase64(v: any, escape?: typeof escape): string;
+export declare function toBase64(v: $TSFixMe, escape?: boolean): string;
 /**
  * Decode base64(base64_url) string to buffer
  *
@@ -66,117 +288,73 @@ declare function toBase64(v: any, escape?: typeof escape): string;
  * @param {string} v
  * @returns {buffer}
  */
-declare function fromBase64(v: string): any;
-/**
- * Generate a random UUID
- *
- * @public
- * @static
- * @returns {string} Generated uuid
- */
-declare function UUID(): string;
-/**
- * Check if a string is valid UUID
- *
- * @public
- * @static
- * @param {string} str
- * @returns {boolean}
- */
-declare function isUUID(str: string): boolean;
+export declare function fromBase64(v: string): Buffer;
 /**
- * Convert address to did: prepend `did:abt:` prefix
+ * Convert did to address: remove `did:abt:` prefix
  *
  * @public
  * @static
  * @param {string} did - address string
  * @returns {string}
  */
-declare function toDid(address: any): string;
+export declare function toAddress(did: string): string;
 /**
- * Convert did to address: remove `did:abt:` prefix
+ * Convert address to did: prepend `did:abt:` prefix
  *
  * @public
  * @static
  * @param {string} did - address string
  * @returns {string}
  */
-declare function toAddress(did: string): string;
-declare namespace ForgeSdkUtil {
-  export interface T100 {
-    BN: typeof bnJs;
-    isBN: (object: any) => boolean;
-    isBigNumber: (object: any) => boolean;
-    isHexPrefixed: (str: string) => boolean;
-    stripHexPrefix: (str: string) => any;
-    utf8ToHex: (str: string) => string;
-    hexToUtf8: (hex: string) => string;
-    numberToHex: (value: string | number | bnJs) => string;
-    hexToNumber: (value: string | number | bnJs) => number;
-    isHex: (hex: string) => boolean;
-    isHexStrict: (hex: string) => boolean;
-    isUint8Array: typeof isUint8Array;
-    hexToBytes: (hex: string) => any[];
-    bytesToHex: (bytes: any[]) => string;
-    toHex: (value: any, returnType: boolean) => string;
-    numberToString: (arg: any) => any;
-    fromUnitToToken: (input: string | number, decimal?: number, optionsInput?: any) => string;
-    fromTokenToUnit: (input: string, decimal?: number) => bnJs;
-    toBN: (number: string | number | bnJs) => bnJs;
-    toUint8Array: typeof toUint8Array;
-    toBuffer: typeof toBuffer;
-    toBase58: typeof toBase58;
-    fromBase58: typeof fromBase58;
-    toBase64: typeof toBase64;
-    fromBase64: typeof fromBase64;
-    UUID: typeof UUID;
-    isUUID: typeof isUUID;
-    toDid: typeof toDid;
-    toAddress: typeof toAddress;
-    formatTxType: (type: any) => any;
-    leftPad: any;
-    rightPad: any;
-  }
-}
-
-/**
- * The structure of a forge wallet type
- *
- * @public
- * @static
- * @global
- * @typedef {Object} DidType
- * @prop {number} role - Enum field to identify wallet role type
- * @prop {number} pk - Crypto algorithm to derive publicKey from the secretKey
- * @prop {number} hash - Hash algorithm used to hash data before sign them
- */
-
+export declare function toDid(address: string): string;
+export declare const formatTxType: (type: string) => string;
+import { BytesType } from '@ocap/util';
+import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
+declare type KeyPairType = {
+  sk?: BytesType;
+  pk?: BytesType;
+  address?: string;
+};
+export declare type SerializedWallet = {
+  type: DIDTypeStr;
+  pk: string;
+  sk: string;
+  address: string;
+};
+export declare type WalletObject = {
+  type: DIDType;
+  secretKey: BytesType;
+  publicKey: BytesType;
+  address: string;
+  hash: (data: BytesType, round?: number) => string;
+  sign: (data: BytesType, hashBeforeSign?: boolean) => BytesType;
+  verify: (data: BytesType, signature: BytesType, hashBeforeVerify?: boolean) => boolean;
+  ethHash: (data: string) => string;
+  ethSign: (data: string, hashBeforeSign?: boolean) => string;
+  ethVerify: (data: string, signature: BytesType, hashBeforeVerify?: boolean) => boolean;
+  toAddress: () => string;
+  toJSON: () => SerializedWallet;
+};
+export declare const WalletType: typeof DidType;
 /**
- * Create an wallet type object that be used as param to create a new wallet
+ * Generate an wallet instance that can be used to sign a message or verify a signature
  *
  * @public
  * @static
- * @param {DidType|string} [type='default']
- * @returns {object}
- * @example
- * const assert = require('assert');
- * const { DidType } = require('@arcblock/did');
- * const { types } = require('@ocap/mcrypto');
- *
- * const type = DidType({
- *   role: types.RoleType.ROLE_APPLICATION,
- *   pk: types.KeyType.ED25519,
- *   hash: types.HashType.SHA3,
- * });
+ * @param {object} keyPair - the key pair
+ * @param {string} keyPair.sk - the secretKey
+ * @param {string} keyPair.pk - the wallet publicKey
+ * @param {DIDTypeArg} [type='default'] - wallet type
+ * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
  */
-declare function DidType(type?: DidType | string): object;
+export declare function Wallet(keyPair: KeyPairType, t?: DIDTypeArg): WalletObject;
 /**
  * Generate a wallet from secretKey
  *
  * @public
  * @static
  * @param {string} sk - the secret key, `hex encoded string`
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
  * @example
  * const assert = require('assert');
@@ -193,30 +371,17 @@ declare function DidType(type?: DidType | string): object;
  * assert.equal(signature, sig, "signature should match");
  * assert.ok(wallet.verify(message, signature), "signature should be verified");
  */
-declare function fromSecretKey(sk: string, _type?: string): WalletObject;
+export declare function fromSecretKey(sk: BytesType, _type?: DIDTypeArg): WalletObject;
 /**
  * Generate a wallet from publicKey
  *
  * @public
  * @static
  * @param {string} pk - the public key, `hex encoded string`
- * @param {DidType} [type='default'] - wallet type
- * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- */
-declare function fromPublicKey(pk: string, _type?: string): WalletObject;
-/**
- * Generate a wallet by generating a random secretKey
- *
- * @public
- * @static
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const { fromRandom } = require('@ocap/wallet');
- * const wallet = fromRandom();
- * // Do something with wallet
  */
-declare function fromRandom(_type?: string): WalletObject;
+export declare function fromPublicKey(pk: BytesType, _type?: DIDTypeArg): WalletObject;
 /**
  * Generate a wallet from address (did)
  *
@@ -226,29 +391,21 @@ declare function fromRandom(_type?: string): WalletObject;
  * @static
  * @param {string} address - the wallet address
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const assert = require('assert');
- * const { fromAddress } = require('@ocap/wallet');
- *
- * const address = 'zNKtCNqYWLYWYW3gWRA1vnRykfCBZYHZvzKr';
- * const wallet = fromAddress(address);
- * console.log(wallet.toJSON());
  */
-declare function fromAddress(address: string): WalletObject;
+export declare function fromAddress(address: string): WalletObject;
 /**
- * Generating a wallet from a serialized json presentation of another wallet
+ * Generate a wallet by generating a random secretKey
  *
  * @public
  * @static
- * @param {object} json - json presentation of a wallet
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const { fromJSON, fromRandom } = require('@ocap/wallet');
- * const wallet = fromRandom();
- * const wallet2 = fromJSON(wallet.toJSON());
- * // wallet2 is identical to wallet
  */
-declare function fromJSON(json: any): WalletObject;
+export declare function fromRandom(_type?: DIDTypeArg): WalletObject;
+/**
+ * Generating a wallet from a serialized json presentation of another wallet
+ */
+export declare function fromJSON(json: SerializedWallet): WalletObject;
 /**
  * Check if an object is valid wallet object
  *
@@ -257,61 +414,8 @@ declare function fromJSON(json: any): WalletObject;
  * @param {object} wallet
  * @param {boolean} canSign - should the wallet support sign
  */
-declare function isValid(wallet: any, canSign?: boolean): boolean;
-/**
- * @public
- * @static
- * @global
- * @name WalletObject
- * @typedef WalletObject
- * @prop {DidType} type - Indicates the wallet type
- * @prop {secretKey} secretKey - Wallet secretKey
- * @prop {publicKey} publicKey - Wallet publicKey
- * @prop {function} sign - Sign `data`, data is hashed using the `HashType` defined in type before signing
- * @prop {function} verify - Verify `signature`, data is hashed using the `HashType` defined in type before verifying
- * @prop {function} toAddress - Get wallet address without `did:abt:` prefix
- * @prop {function} toJSON - Serialize wallet to json object, checkout {@link fromJSON} for deserialisation
- */
-
-/**
- * Generate an wallet instance that can be used to sign a message or verify a signature
- *
- * @public
- * @static
- * @param {object} keyPair - the key pair
- * @param {string} keyPair.sk - the secretKey
- * @param {string} keyPair.pk - the wallet publicKey
- * @param {DidType} [type='default'] - wallet type
- * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- */
-declare function Wallet(keyPair: ForgeSdkWallet.T100, type?: typeof DidType): WalletObject;
-declare namespace ForgeSdkWallet {
-  export interface WalletObject {
-    type: typeof DidType;
-    secretKey: any;
-    publicKey: any;
-    sign: (...args: any[]) => any;
-    verify: (...args: any[]) => any;
-    toAddress: (...args: any[]) => any;
-    toJSON: (...args: any[]) => any;
-  }
-  export interface T100 {
-    sk: string;
-    pk: string;
-  }
-  export interface T101 {
-    fromSecretKey: typeof fromSecretKey;
-    fromPublicKey: typeof fromPublicKey;
-    fromRandom: typeof fromRandom;
-    fromAddress: typeof fromAddress;
-    fromDID: typeof fromAddress;
-    fromJSON: typeof fromJSON;
-    isValid: typeof isValid;
-    Wallet: typeof Wallet;
-    WalletType: typeof DidType;
-    DidType: typeof DidType;
-  }
-}
+export declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
+export {};
 
 import * as LibMessage from './lib/message';
 declare const _OcapMessage: typeof LibMessage;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ocap/sdk",
   "description": "Forge javascript SDK packages all-in-one",
-  "version": "1.16.16",
+  "version": "1.17.1",
   "author": {
     "name": "wangshijun",
     "email": "shijun@arcblock.io",
@@ -18,11 +18,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@arcblock/did-util": "1.16.16",
-    "@ocap/client": "1.16.16",
-    "@ocap/message": "1.16.16",
-    "@ocap/util": "1.16.16",
-    "@ocap/wallet": "1.16.16",
+    "@arcblock/did-util": "1.17.1",
+    "@ocap/client": "1.17.1",
+    "@ocap/message": "1.17.1",
+    "@ocap/util": "1.17.1",
+    "@ocap/wallet": "1.17.1",
     "debug": "^4.3.3",
     "react-app-polyfill": "^1.0.1"
   },
@@ -79,5 +79,5 @@
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "yarn test -- --coverage"
   },
-  "gitHead": "051f9620995cf24407374cc4811b0fa6ed6dc7ca"
+  "gitHead": "ca2ac264d9d6358680d5be99fcdd4685d0c999fc"
 }