neeboo
6 years ago
parent
8a6f7022ea
commit
53ceffaef4
@ -1 +1 @@ |
||||
.babelrc |
||||
.babelrc |
||||
|
||||
@ -0,0 +1,386 @@ |
||||
// This file is ported from ether.js/src.ts/utils/bytes.ts
|
||||
|
||||
import * as errors from './errors'; |
||||
|
||||
export type Arrayish = string | ArrayLike<number>; |
||||
|
||||
export interface Hexable { |
||||
toHexString(): string; |
||||
} |
||||
|
||||
export interface Signature { |
||||
r: string; |
||||
s: string; |
||||
|
||||
/* At least one of the following MUST be specified; the other will be derived */ |
||||
recoveryParam?: number; |
||||
v?: number; |
||||
} |
||||
|
||||
///////////////////////////////
|
||||
|
||||
export function isHexable(value: any): value is Hexable { |
||||
return !!value.toHexString; |
||||
} |
||||
|
||||
function addSlice(array: Uint8Array): Uint8Array { |
||||
if (array.slice) { |
||||
return array; |
||||
} |
||||
|
||||
// tslint:disable-next-line: only-arrow-functions
|
||||
array.slice = function() { |
||||
const args = Array.prototype.slice.call(arguments); |
||||
return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args))); |
||||
}; |
||||
|
||||
return array; |
||||
} |
||||
|
||||
export function isArrayish(value: any): value is Arrayish { |
||||
if ( |
||||
!value || |
||||
// tslint:disable-next-line: radix
|
||||
parseInt(String(value.length)) !== value.length || |
||||
typeof value === 'string' |
||||
) { |
||||
return false; |
||||
} |
||||
|
||||
// tslint:disable-next-line: prefer-for-of
|
||||
for (let i = 0; i < value.length; i++) { |
||||
const v = value[i]; |
||||
// tslint:disable-next-line: radix
|
||||
if (v < 0 || v >= 256 || parseInt(String(v)) !== v) { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
export function arrayify(value: Arrayish | Hexable): Uint8Array { |
||||
if (value == null) { |
||||
errors.throwError( |
||||
'cannot convert null value to array', |
||||
errors.INVALID_ARGUMENT, |
||||
{ arg: 'value', value }, |
||||
); |
||||
} |
||||
|
||||
if (isHexable(value)) { |
||||
value = value.toHexString(); |
||||
} |
||||
|
||||
if (typeof value === 'string') { |
||||
const match = value.match(/^(0x)?[0-9a-fA-F]*$/); |
||||
|
||||
if (!match) { |
||||
errors.throwError('invalid hexidecimal string', errors.INVALID_ARGUMENT, { |
||||
arg: 'value', |
||||
value, |
||||
}); |
||||
} |
||||
|
||||
if (match[1] !== '0x') { |
||||
errors.throwError( |
||||
'hex string must have 0x prefix', |
||||
errors.INVALID_ARGUMENT, |
||||
{ arg: 'value', value }, |
||||
); |
||||
} |
||||
|
||||
value = value.substring(2); |
||||
if (value.length % 2) { |
||||
value = '0' + value; |
||||
} |
||||
|
||||
const result = []; |
||||
for (let i = 0; i < value.length; i += 2) { |
||||
result.push(parseInt(value.substr(i, 2), 16)); |
||||
} |
||||
|
||||
return addSlice(new Uint8Array(result)); |
||||
} |
||||
|
||||
if (isArrayish(value)) { |
||||
return addSlice(new Uint8Array(value)); |
||||
} |
||||
|
||||
errors.throwError('invalid arrayify value', null, { |
||||
arg: 'value', |
||||
value, |
||||
type: typeof value, |
||||
}); |
||||
return null; |
||||
} |
||||
|
||||
export function concat(objects: Arrayish[]): Uint8Array { |
||||
const arrays = []; |
||||
let length = 0; |
||||
// tslint:disable-next-line: prefer-for-of
|
||||
for (let i = 0; i < objects.length; i++) { |
||||
const object = arrayify(objects[i]); |
||||
arrays.push(object); |
||||
length += object.length; |
||||
} |
||||
|
||||
const result = new Uint8Array(length); |
||||
let offset = 0; |
||||
// tslint:disable-next-line: prefer-for-of
|
||||
for (let i = 0; i < arrays.length; i++) { |
||||
result.set(arrays[i], offset); |
||||
offset += arrays[i].length; |
||||
} |
||||
|
||||
return addSlice(result); |
||||
} |
||||
|
||||
export function stripZeros(value: Arrayish): Uint8Array { |
||||
let result: Uint8Array = arrayify(value); |
||||
|
||||
if (result.length === 0) { |
||||
return result; |
||||
} |
||||
|
||||
// Find the first non-zero entry
|
||||
let start = 0; |
||||
while (result[start] === 0) { |
||||
start++; |
||||
} |
||||
|
||||
// If we started with zeros, strip them
|
||||
if (start) { |
||||
result = result.slice(start); |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
export function padZeros(value: Arrayish, length: number): Uint8Array { |
||||
value = arrayify(value); |
||||
|
||||
if (length < value.length) { |
||||
throw new Error('cannot pad'); |
||||
} |
||||
|
||||
const result = new Uint8Array(length); |
||||
result.set(value, length - value.length); |
||||
return addSlice(result); |
||||
} |
||||
|
||||
export function isHexString(value: any, length?: number): boolean { |
||||
if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) { |
||||
return false; |
||||
} |
||||
if (length && value.length !== 2 + 2 * length) { |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
const HexCharacters: string = '0123456789abcdef'; |
||||
|
||||
export function hexlify(value: Arrayish | Hexable | number): string { |
||||
if (isHexable(value)) { |
||||
return value.toHexString(); |
||||
} |
||||
|
||||
if (typeof value === 'number') { |
||||
if (value < 0) { |
||||
errors.throwError( |
||||
'cannot hexlify negative value', |
||||
errors.INVALID_ARGUMENT, |
||||
{ arg: 'value', value }, |
||||
); |
||||
} |
||||
|
||||
// @TODO: Roll this into the above error as a numeric fault (overflow); next version, not backward compatible
|
||||
// We can about (value == MAX_INT) to as well, since that may indicate we underflowed already
|
||||
if (value >= 9007199254740991) { |
||||
errors.throwError('out-of-range', errors.NUMERIC_FAULT, { |
||||
operartion: 'hexlify', |
||||
fault: 'out-of-safe-range', |
||||
}); |
||||
} |
||||
|
||||
let hex = ''; |
||||
while (value) { |
||||
hex = HexCharacters[value & 0x0f] + hex; |
||||
value = Math.floor(value / 16); |
||||
} |
||||
|
||||
if (hex.length) { |
||||
if (hex.length % 2) { |
||||
hex = '0' + hex; |
||||
} |
||||
return '0x' + hex; |
||||
} |
||||
|
||||
return '0x00'; |
||||
} |
||||
|
||||
if (typeof value === 'string') { |
||||
const match = value.match(/^(0x)?[0-9a-fA-F]*$/); |
||||
|
||||
if (!match) { |
||||
errors.throwError('invalid hexidecimal string', errors.INVALID_ARGUMENT, { |
||||
arg: 'value', |
||||
value, |
||||
}); |
||||
} |
||||
|
||||
if (match[1] !== '0x') { |
||||
errors.throwError( |
||||
'hex string must have 0x prefix', |
||||
errors.INVALID_ARGUMENT, |
||||
{ arg: 'value', value }, |
||||
); |
||||
} |
||||
|
||||
if (value.length % 2) { |
||||
value = '0x0' + value.substring(2); |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
if (isArrayish(value)) { |
||||
const result = []; |
||||
// tslint:disable-next-line: prefer-for-of
|
||||
for (let i = 0; i < value.length; i++) { |
||||
const v = value[i]; |
||||
result.push(HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f]); |
||||
} |
||||
return '0x' + result.join(''); |
||||
} |
||||
|
||||
errors.throwError('invalid hexlify value', null, { |
||||
arg: 'value', |
||||
value, |
||||
}); |
||||
return 'never'; |
||||
} |
||||
|
||||
export function hexDataLength(data: string) { |
||||
if (!isHexString(data) || data.length % 2 !== 0) { |
||||
return null; |
||||
} |
||||
return (data.length - 2) / 2; |
||||
} |
||||
|
||||
export function hexDataSlice( |
||||
data: string, |
||||
offset: number, |
||||
endOffset?: number, |
||||
): string { |
||||
if (!isHexString(data)) { |
||||
errors.throwError('invalid hex data', errors.INVALID_ARGUMENT, { |
||||
arg: 'value', |
||||
value: data, |
||||
}); |
||||
} |
||||
if (data.length % 2 !== 0) { |
||||
errors.throwError('hex data length must be even', errors.INVALID_ARGUMENT, { |
||||
arg: 'value', |
||||
value: data, |
||||
}); |
||||
} |
||||
offset = 2 + 2 * offset; |
||||
|
||||
if (endOffset != null) { |
||||
return '0x' + data.substring(offset, 2 + 2 * endOffset); |
||||
} |
||||
|
||||
return '0x' + data.substring(offset); |
||||
} |
||||
|
||||
export function hexStripZeros(value: string): string { |
||||
if (!isHexString(value)) { |
||||
errors.throwError('invalid hex string', errors.INVALID_ARGUMENT, { |
||||
arg: 'value', |
||||
value, |
||||
}); |
||||
} |
||||
while (value.length > 3 && value.substring(0, 3) === '0x0') { |
||||
value = '0x' + value.substring(3); |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
export function hexZeroPad(value: string, length: number): string { |
||||
if (!isHexString(value)) { |
||||
errors.throwError('invalid hex string', errors.INVALID_ARGUMENT, { |
||||
arg: 'value', |
||||
value, |
||||
}); |
||||
} |
||||
|
||||
while (value.length < 2 * length + 2) { |
||||
value = '0x0' + value.substring(2); |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
function isSignature(value: any): value is Signature { |
||||
return value && value.r != null && value.s != null; |
||||
} |
||||
|
||||
export function splitSignature(signature: Arrayish | Signature): Signature { |
||||
let v = 0; |
||||
let r = '0x'; |
||||
let s = '0x'; |
||||
|
||||
if (isSignature(signature)) { |
||||
if (signature.v == null && signature.recoveryParam == null) { |
||||
errors.throwError( |
||||
'at least on of recoveryParam or v must be specified', |
||||
errors.INVALID_ARGUMENT, |
||||
{ argument: 'signature', value: signature }, |
||||
); |
||||
} |
||||
r = hexZeroPad(signature.r, 32); |
||||
s = hexZeroPad(signature.s, 32); |
||||
|
||||
v = signature.v; |
||||
if (typeof v === 'string') { |
||||
v = parseInt(v, 16); |
||||
} |
||||
|
||||
let recoveryParam = signature.recoveryParam; |
||||
if (recoveryParam == null && signature.v != null) { |
||||
recoveryParam = 1 - (v % 2); |
||||
} |
||||
v = 27 + recoveryParam; |
||||
} else { |
||||
const bytes: Uint8Array = arrayify(signature); |
||||
if (bytes.length !== 65) { |
||||
throw new Error('invalid signature'); |
||||
} |
||||
r = hexlify(bytes.slice(0, 32)); |
||||
s = hexlify(bytes.slice(32, 64)); |
||||
|
||||
v = bytes[64]; |
||||
if (v !== 27 && v !== 28) { |
||||
v = 27 + (v % 2); |
||||
} |
||||
} |
||||
|
||||
return { |
||||
r, |
||||
s, |
||||
recoveryParam: v - 27, |
||||
v, |
||||
}; |
||||
} |
||||
|
||||
export function joinSignature(signature: Signature): string { |
||||
signature = splitSignature(signature); |
||||
|
||||
return hexlify( |
||||
concat([ |
||||
signature.r, |
||||
signature.s, |
||||
signature.recoveryParam ? '0x1c' : '0x1b', |
||||
]), |
||||
); |
||||
} |
||||
@ -0,0 +1,201 @@ |
||||
// This file is ported from ether.js/src.ts/errors.ts
|
||||
|
||||
// Unknown Error
|
||||
export const UNKNOWN_ERROR = 'UNKNOWN_ERROR'; |
||||
|
||||
// Not implemented
|
||||
export const NOT_IMPLEMENTED = 'NOT_IMPLEMENTED'; |
||||
|
||||
// Missing new operator to an object
|
||||
// - name: The name of the class
|
||||
export const MISSING_NEW = 'MISSING_NEW'; |
||||
|
||||
// Call exception
|
||||
// - transaction: the transaction
|
||||
// - address?: the contract address
|
||||
// - args?: The arguments passed into the function
|
||||
// - method?: The Solidity method signature
|
||||
// - errorSignature?: The EIP848 error signature
|
||||
// - errorArgs?: The EIP848 error parameters
|
||||
// - reason: The reason (only for EIP848 "Error(string)")
|
||||
export const CALL_EXCEPTION = 'CALL_EXCEPTION'; |
||||
|
||||
// Invalid argument (e.g. value is incompatible with type) to a function:
|
||||
// - argument: The argument name that was invalid
|
||||
// - value: The value of the argument
|
||||
export const INVALID_ARGUMENT = 'INVALID_ARGUMENT'; |
||||
|
||||
// Missing argument to a function:
|
||||
// - count: The number of arguments received
|
||||
// - expectedCount: The number of arguments expected
|
||||
export const MISSING_ARGUMENT = 'MISSING_ARGUMENT'; |
||||
|
||||
// Too many arguments
|
||||
// - count: The number of arguments received
|
||||
// - expectedCount: The number of arguments expected
|
||||
export const UNEXPECTED_ARGUMENT = 'UNEXPECTED_ARGUMENT'; |
||||
|
||||
// Numeric Fault
|
||||
// - operation: the operation being executed
|
||||
// - fault: the reason this faulted
|
||||
export const NUMERIC_FAULT = 'NUMERIC_FAULT'; |
||||
|
||||
// Insufficien funds (< value + gasLimit * gasPrice)
|
||||
// - transaction: the transaction attempted
|
||||
export const INSUFFICIENT_FUNDS = 'INSUFFICIENT_FUNDS'; |
||||
|
||||
// Nonce has already been used
|
||||
// - transaction: the transaction attempted
|
||||
export const NONCE_EXPIRED = 'NONCE_EXPIRED'; |
||||
|
||||
// The replacement fee for the transaction is too low
|
||||
// - transaction: the transaction attempted
|
||||
export const REPLACEMENT_UNDERPRICED = 'REPLACEMENT_UNDERPRICED'; |
||||
|
||||
// Unsupported operation
|
||||
// - operation
|
||||
export const UNSUPPORTED_OPERATION = 'UNSUPPORTED_OPERATION'; |
||||
|
||||
// tslint:disable-next-line: variable-name
|
||||
let _permanentCensorErrors = false; |
||||
// tslint:disable-next-line: variable-name
|
||||
let _censorErrors = false; |
||||
|
||||
// @TODO: Enum
|
||||
export function throwError(message: string, code: string, params: any): never { |
||||
if (_censorErrors) { |
||||
throw new Error('unknown error'); |
||||
} |
||||
|
||||
if (!code) { |
||||
code = UNKNOWN_ERROR; |
||||
} |
||||
if (!params) { |
||||
params = {}; |
||||
} |
||||
|
||||
const messageDetails: string[] = []; |
||||
Object.keys(params).forEach((key) => { |
||||
try { |
||||
messageDetails.push(key + '=' + JSON.stringify(params[key])); |
||||
} catch (error) { |
||||
messageDetails.push(key + '=' + JSON.stringify(params[key].toString())); |
||||
} |
||||
}); |
||||
messageDetails.push('version=' + '#version'); |
||||
|
||||
const reason = message; |
||||
if (messageDetails.length) { |
||||
message += ' (' + messageDetails.join(', ') + ')'; |
||||
} |
||||
|
||||
// @TODO: Any??
|
||||
const error: any = new Error(message); |
||||
error.reason = reason; |
||||
error.code = code; |
||||
|
||||
Object.keys(params).forEach((key) => { |
||||
error[key] = params[key]; |
||||
}); |
||||
|
||||
throw error; |
||||
} |
||||
|
||||
export function checkNew(self: any, kind: any): void { |
||||
if (!(self instanceof kind)) { |
||||
throwError('missing new', MISSING_NEW, { name: kind.name }); |
||||
} |
||||
} |
||||
|
||||
export function checkArgumentCount( |
||||
count: number, |
||||
expectedCount: number, |
||||
suffix?: string, |
||||
): void { |
||||
if (!suffix) { |
||||
suffix = ''; |
||||
} |
||||
if (count < expectedCount) { |
||||
throwError('missing argument' + suffix, MISSING_ARGUMENT, { |
||||
count, |
||||
expectedCount, |
||||
}); |
||||
} |
||||
if (count > expectedCount) { |
||||
throwError('too many arguments' + suffix, UNEXPECTED_ARGUMENT, { |
||||
count, |
||||
expectedCount, |
||||
}); |
||||
} |
||||
} |
||||
|
||||
export function setCensorship(censorship: boolean, permanent?: boolean): void { |
||||
if (_permanentCensorErrors) { |
||||
throwError('error censorship permanent', UNSUPPORTED_OPERATION, { |
||||
operation: 'setCensorship', |
||||
}); |
||||
} |
||||
|
||||
_censorErrors = !!censorship; |
||||
_permanentCensorErrors = !!permanent; |
||||
} |
||||
|
||||
export function checkNormalize(): void { |
||||
try { |
||||
// Make sure all forms of normalization are supported
|
||||
['NFD', 'NFC', 'NFKD', 'NFKC'].forEach((form) => { |
||||
try { |
||||
'test'.normalize(form); |
||||
} catch (error) { |
||||
throw new Error('missing ' + form); |
||||
} |
||||
}); |
||||
|
||||
if ( |
||||
String.fromCharCode(0xe9).normalize('NFD') !== |
||||
String.fromCharCode(0x65, 0x0301) |
||||
) { |
||||
throw new Error('broken implementation'); |
||||
} |
||||
} catch (error) { |
||||
throwError( |
||||
'platform missing String.prototype.normalize', |
||||
UNSUPPORTED_OPERATION, |
||||
{ operation: 'String.prototype.normalize', form: error.message }, |
||||
); |
||||
} |
||||
} |
||||
|
||||
const LogLevels: { [name: string]: number } = { |
||||
debug: 1, |
||||
default: 2, |
||||
info: 2, |
||||
warn: 3, |
||||
error: 4, |
||||
off: 5, |
||||
}; |
||||
let LogLevel = LogLevels.default; |
||||
|
||||
export function setLogLevel(logLevel: string): void { |
||||
const level = LogLevels[logLevel]; |
||||
if (level == null) { |
||||
warn('invliad log level - ' + logLevel); |
||||
return; |
||||
} |
||||
LogLevel = level; |
||||
} |
||||
|
||||
function log(logLevel: string, args: any[]): void { |
||||
if (LogLevel > LogLevels[logLevel]) { |
||||
return; |
||||
} |
||||
console.log.apply(console, args); |
||||
} |
||||
|
||||
export function warn(...args: any[]): void { |
||||
log('warn', args); |
||||
} |
||||
|
||||
export function info(...args: any[]): void { |
||||
log('info', args); |
||||
} |
||||
@ -1 +1,2 @@ |
||||
export { randomBytes } from './random'; |
||||
export * from './random'; |
||||
export * from './keyTool'; |
||||
|
||||
@ -0,0 +1,7 @@ |
||||
import * as sha3 from 'js-sha3'; |
||||
|
||||
import { arrayify, Arrayish } from './bytes'; |
||||
|
||||
export function keccak256(data: Arrayish): string { |
||||
return '0x' + sha3.keccak_256(arrayify(data)); |
||||
} |
||||
@ -0,0 +1,69 @@ |
||||
import elliptic from 'elliptic'; |
||||
import * as bytes from './bytes'; |
||||
import * as errors from './errors'; |
||||
import { keccak256 } from './keccak256'; |
||||
import { randomBytes } from './random'; |
||||
|
||||
const secp256k1 = elliptic.ec('secp256k1'); |
||||
|
||||
export const generatePrivateKey = (): string => { |
||||
const entropy: string = '0x' + randomBytes(16); |
||||
const innerHex: string = keccak256( |
||||
bytes.concat(['0x' + randomBytes(32), entropy || '0x' + randomBytes(32)]), |
||||
); |
||||
const middleHex: Uint8Array = bytes.concat([ |
||||
bytes.concat(['0x' + randomBytes(32), innerHex]), |
||||
'0x' + randomBytes(32), |
||||
]); |
||||
const outerHex: string = keccak256(middleHex); |
||||
return outerHex; |
||||
}; |
||||
|
||||
export const getPubkeyFromPrivateKey = (privateKey: string): string => { |
||||
const buffer = new Buffer(privateKey.slice(2), 'hex'); |
||||
const ecKey = secp256k1.keyFromPrivate(buffer); |
||||
const pubK = '0x' + ecKey.getPublic(false, 'hex').slice(2); |
||||
const publicKey = keccak256(pubK); |
||||
return publicKey; |
||||
}; |
||||
|
||||
export const getAddressFromPrivateKey = (privateKey: string): string => { |
||||
const publicKey = getPubkeyFromPrivateKey(privateKey); |
||||
const address = '0x' + publicKey.slice(-40); |
||||
return address; |
||||
}; |
||||
|
||||
export const getAddressFromPublicKey = (publicKey: string): string => { |
||||
const address = '0x' + publicKey.slice(-40); |
||||
return address; |
||||
}; |
||||
|
||||
export const toChecksumAddress = (address: string): string => { |
||||
if (typeof address !== 'string' || !address.match(/^0x[0-9A-Fa-f]{40}$/)) { |
||||
errors.throwError('invalid address', errors.INVALID_ARGUMENT, { |
||||
arg: 'address', |
||||
value: address, |
||||
}); |
||||
} |
||||
|
||||
address = address.toLowerCase(); |
||||
|
||||
const chars = address.substring(2).split(''); |
||||
|
||||
let hashed = new Uint8Array(40); |
||||
for (let i = 0; i < 40; i++) { |
||||
hashed[i] = chars[i].charCodeAt(0); |
||||
} |
||||
hashed = bytes.arrayify(keccak256(hashed)); |
||||
|
||||
for (let i = 0; i < 40; i += 2) { |
||||
if (hashed[i >> 1] >> 4 >= 8) { |
||||
chars[i] = chars[i].toUpperCase(); |
||||
} |
||||
if ((hashed[i >> 1] & 0x0f) >= 8) { |
||||
chars[i + 1] = chars[i + 1].toUpperCase(); |
||||
} |
||||
} |
||||
|
||||
return '0x' + chars.join(''); |
||||
}; |
||||
@ -0,0 +1,4 @@ |
||||
{ |
||||
"extends": "../../tsconfig.base.json", |
||||
"include": ["src", "../../typings/**/*.d.ts"] |
||||
} |
||||
@ -0,0 +1,61 @@ |
||||
import BN from 'bn.js'; |
||||
import hash from 'hash.js'; |
||||
|
||||
declare namespace Elliptic { |
||||
type HexEnc = 'hex'; |
||||
type Utf8Enc = 'utf8'; |
||||
type CurveTypes = 'short' | 'edwards' | 'mont'; |
||||
type PrivateKey = |
||||
| string |
||||
| Buffer |
||||
| { x: Buffer; y: Buffer } |
||||
| { x: string; y: string }; |
||||
|
||||
interface Curve { |
||||
type: CurveTypes; |
||||
n: BN; |
||||
g: Point; |
||||
decodePoint(msg: Buffer | Array<any> | string, enc?: string): Point; |
||||
validate(point: Point): boolean; |
||||
} |
||||
|
||||
interface Point { |
||||
x: BN; |
||||
y: BN; |
||||
inf: boolean; |
||||
encode(enc: string, compressed?: boolean): Array<number>; |
||||
encodeCompressed(enc?: string): Array<number>; |
||||
isInfinity(): boolean; |
||||
add(k: BN | Number | Point): Point; |
||||
mul(k: BN | Number | Point): Point; |
||||
} |
||||
|
||||
interface EC { |
||||
curve: Curve; |
||||
genKeyPair(opt?: GenKeyPairOpt): KeyPair; |
||||
keyFromPrivate(priv: string, enc: string): KeyPair; |
||||
keyFromPublic(pub: string, enc: string): KeyPair; |
||||
} |
||||
|
||||
interface GenKeyPairOpt { |
||||
entropy?: string | Buffer; |
||||
entropyEnc?: HexEnc | Utf8Enc; |
||||
pers?: string | Buffer; |
||||
persEnc?: HexEnc | Utf8Enc; |
||||
} |
||||
|
||||
interface KeyPair { |
||||
fromPublic(ec: Curve, pub: BN, enc: string): KeyPair; |
||||
fromPrivate(ec: Curve, priv: BN, enc: string): KeyPair; |
||||
// this is broken, but we can't fix it without changing the upstream
|
||||
// library; compact is optional, but optional parameters should always
|
||||
// _follow_ mandatory ones.
|
||||
getPublic(compact: boolean, enc: string): string; |
||||
getPrivate<T = undefined>(enc?: T): T extends HexEnc ? string : BN; |
||||
validate(): { result: boolean; reason: string | null }; |
||||
} |
||||
|
||||
export function ec(curve: string): EC; |
||||
} |
||||
|
||||
export = Elliptic; |
||||
@ -0,0 +1,67 @@ |
||||
const path = require('path'); |
||||
const UglifyJs = require('uglifyjs-webpack-plugin'); |
||||
const packagesSettings = require('./scripts/packagesList'); |
||||
|
||||
function createBatchConfig(list) { |
||||
return list.map((l) => { |
||||
const entryBase = {}; |
||||
entryBase[l.name] = [`./packages/${l.dest}/lib/index.js`]; |
||||
|
||||
const batchBaseConfig = { |
||||
entry: entryBase, |
||||
mode: 'production', |
||||
module: { |
||||
rules: [ |
||||
{ |
||||
test: /\.js$/, |
||||
use: { |
||||
loader: 'babel-loader', |
||||
}, |
||||
}, |
||||
], |
||||
}, |
||||
devtool: 'source-map', |
||||
resolve: { |
||||
symlinks: true, |
||||
extensions: ['.js'], |
||||
}, |
||||
}; |
||||
|
||||
const batchClientConfig = { |
||||
...batchBaseConfig, |
||||
optimization: { |
||||
minimizer: [ |
||||
new UglifyJs({ |
||||
uglifyOptions: { |
||||
compress: true, |
||||
mangle: true, |
||||
toplevel: false, |
||||
output: { |
||||
beautify: false, |
||||
comments: false, |
||||
}, |
||||
}, |
||||
parallel: true, |
||||
sourceMap: true, |
||||
}), |
||||
], |
||||
}, |
||||
output: { |
||||
libraryTarget: 'umd', |
||||
library: `${l.name}`, |
||||
filename: '[name].browser.js', |
||||
path: path.join(__dirname, 'dist'), |
||||
}, |
||||
}; |
||||
|
||||
return [batchBaseConfig, batchClientConfig]; |
||||
}); |
||||
} |
||||
|
||||
function reduceDimension(arr) { |
||||
return Array.prototype.concat.apply([], arr); |
||||
} |
||||
|
||||
const batch = reduceDimension(createBatchConfig(packagesSettings)); |
||||
|
||||
module.exports = batch; |
||||
Loading…
Reference in new issue