541 lines
9.0 KiB
TypeScript
541 lines
9.0 KiB
TypeScript
declare module 'bn.js' {
|
|
import { Buffer } from 'buffer';
|
|
|
|
type Endianness = 'le' | 'be';
|
|
type IPrimeName = 'k256' | 'p224' | 'p192' | 'p25519';
|
|
class RedBN {
|
|
redAdd(b: RedBN): RedBN;
|
|
redIAdd(b: RedBN): RedBN;
|
|
redSub(b: RedBN): RedBN;
|
|
redISub(b: RedBN): RedBN;
|
|
redShl(num: number): RedBN;
|
|
redMul(b: RedBN): RedBN;
|
|
redIMul(b: RedBN): RedBN;
|
|
redSqr(): RedBN;
|
|
redISqr(): RedBN;
|
|
/**
|
|
* @description square root modulo reduction context's prime
|
|
*/
|
|
redSqrt(): RedBN;
|
|
/**
|
|
* @description modular inverse of the number
|
|
*/
|
|
redInvm(): RedBN;
|
|
redNeg(): RedBN;
|
|
/**
|
|
* @description modular exponentiation
|
|
*/
|
|
redPow(b: RedBN): RedBN;
|
|
fromRed(): BN;
|
|
}
|
|
|
|
// FIXME: not sure how to specify the reduction context here
|
|
interface IReductionContext {
|
|
m: number;
|
|
prime: object;
|
|
[key: string]: any;
|
|
}
|
|
|
|
export default class BN {
|
|
constructor(
|
|
number: number | string | number[] | Buffer | BN,
|
|
base?: number,
|
|
endian?: Endianness
|
|
);
|
|
/**
|
|
* @description create a reduction context
|
|
*/
|
|
|
|
static red(reductionContext: BN | IPrimeName): IReductionContext;
|
|
/**
|
|
* @description create a reduction context with the Montgomery trick.
|
|
*/
|
|
|
|
static mont(num: BN): IReductionContext;
|
|
/**
|
|
* @description Convert number to red
|
|
*/
|
|
|
|
/**
|
|
* @description returns true if the supplied object is a BN.js instance
|
|
*/
|
|
|
|
static isBN(b: object): boolean;
|
|
|
|
toRed(reductionContext: IReductionContext): RedBN;
|
|
/**
|
|
* @description clone number
|
|
*/
|
|
|
|
clone(): BN;
|
|
|
|
/**
|
|
* @description convert to base-string and pad with zeroes
|
|
*/
|
|
|
|
toString(base?: number, length?: number): string;
|
|
|
|
/**
|
|
* @description convert to Javascript Number (limited to 53 bits)
|
|
*/
|
|
|
|
toNumber(): number;
|
|
|
|
/**
|
|
* @description convert to JSON compatible hex string (alias of toString(16))
|
|
*/
|
|
|
|
toJSON(): string;
|
|
|
|
/**
|
|
* @description convert to byte Array, and optionally zero pad to length, throwing if already exceeding
|
|
*/
|
|
|
|
toArray(endian?: Endianness, length?: number): number[];
|
|
|
|
/**
|
|
* @description convert to an instance of `type`, which must behave like an Array
|
|
*/
|
|
toArrayLike(
|
|
ArrayType: Buffer | Array<any>,
|
|
endian?: Endianness,
|
|
length?: number
|
|
): Buffer | Array<any>;
|
|
|
|
/**
|
|
* @description convert to Node.js Buffer (if available). For compatibility with browserify and similar tools, use this instead: a.toArrayLike(Buffer, endian, length)
|
|
*/
|
|
toBuffer(endian?: Endianness, length?: number): Buffer;
|
|
|
|
/**
|
|
* @description get number of bits occupied
|
|
*/
|
|
|
|
bitLength(): number;
|
|
|
|
/**
|
|
* @description return number of less-significant consequent zero bits (example: 1010000 has 4 zero bits)
|
|
*/
|
|
|
|
zeroBits(): number;
|
|
|
|
/**
|
|
* @description return number of bytes occupied
|
|
*/
|
|
|
|
byteLength(): number;
|
|
|
|
/**
|
|
* @description true if the number is negative
|
|
*/
|
|
|
|
isNeg(): boolean;
|
|
|
|
/**
|
|
* @description no comments
|
|
*/
|
|
|
|
isEven(): boolean;
|
|
|
|
/**
|
|
* @description no comments
|
|
*/
|
|
|
|
isOdd(): boolean;
|
|
|
|
/**
|
|
* @description no comments
|
|
*/
|
|
|
|
isZero(): boolean;
|
|
|
|
/**
|
|
* @description compare numbers and return `-1 (a < b)`, `0 (a == b)`, or `1 (a > b)` depending on the comparison result
|
|
*/
|
|
|
|
cmp(b: BN): -1 | 0 | 1;
|
|
|
|
/**
|
|
* @description compare numbers and return `-1 (a < b)`, `0 (a == b)`, or `1 (a > b)` depending on the comparison result
|
|
*/
|
|
|
|
ucmp(b: BN): -1 | 0 | 1;
|
|
|
|
/**
|
|
* @description compare numbers and return `-1 (a < b)`, `0 (a == b)`, or `1 (a > b)` depending on the comparison result
|
|
*/
|
|
|
|
cmpn(b: number): -1 | 0 | 1;
|
|
|
|
/**
|
|
* @description a less than b
|
|
*/
|
|
|
|
lt(b: BN): boolean;
|
|
|
|
/**
|
|
* @description a less than b
|
|
*/
|
|
|
|
ltn(b: number): boolean;
|
|
|
|
/**
|
|
* @description a less than or equals b
|
|
*/
|
|
|
|
lte(b: BN): boolean;
|
|
|
|
/**
|
|
* @description a less than or equals b
|
|
*/
|
|
|
|
lten(b: number): boolean;
|
|
|
|
/**
|
|
* @description a greater than b
|
|
*/
|
|
|
|
gt(b: BN): boolean;
|
|
|
|
/**
|
|
* @description a greater than b
|
|
*/
|
|
|
|
gtn(b: number): boolean;
|
|
|
|
/**
|
|
* @description a greater than or equals b
|
|
*/
|
|
|
|
gte(b: BN): boolean;
|
|
|
|
/**
|
|
* @description a greater than or equals b
|
|
*/
|
|
|
|
gten(b: number): boolean;
|
|
|
|
/**
|
|
* @description a equals b
|
|
*/
|
|
|
|
eq(b: BN): boolean;
|
|
|
|
/**
|
|
* @description a equals b
|
|
*/
|
|
|
|
eqn(b: number): boolean;
|
|
|
|
/**
|
|
* @description convert to two's complement representation, where width is bit width
|
|
*/
|
|
|
|
toTwos(width: number): BN;
|
|
|
|
/**
|
|
* @description convert from two's complement representation, where width is the bit width
|
|
*/
|
|
|
|
fromTwos(width: number): BN;
|
|
|
|
/**
|
|
* @description negate sign
|
|
*/
|
|
|
|
neg(): BN;
|
|
|
|
/**
|
|
* @description negate sign
|
|
*/
|
|
|
|
ineg(): BN;
|
|
|
|
/**
|
|
* @description absolute value
|
|
*/
|
|
|
|
abs(): BN;
|
|
|
|
/**
|
|
* @description absolute value
|
|
*/
|
|
|
|
iabs(): BN;
|
|
|
|
/**
|
|
* @description addition
|
|
*/
|
|
|
|
add(b: BN): BN;
|
|
/**
|
|
* @description addition
|
|
*/
|
|
|
|
iadd(b: BN): BN;
|
|
addition;
|
|
/**
|
|
* @description addition
|
|
*/
|
|
|
|
addn(b: number): BN;
|
|
/**
|
|
* @description addition
|
|
*/
|
|
|
|
iaddn(b: number): BN;
|
|
|
|
/**
|
|
* @description subtraction
|
|
*/
|
|
|
|
sub(b: BN): BN;
|
|
/**
|
|
* @description subtraction
|
|
*/
|
|
|
|
isub(b: BN): BN;
|
|
/**
|
|
* @description subtraction
|
|
*/
|
|
|
|
subn(b: number): BN;
|
|
/**
|
|
* @description subtraction
|
|
*/
|
|
|
|
isubn(b: number): BN;
|
|
|
|
/**
|
|
* @description multiply
|
|
*/
|
|
|
|
mul(b: BN): BN;
|
|
/**
|
|
* @description multiply
|
|
*/
|
|
|
|
imul(b: BN): BN;
|
|
/**
|
|
* @description multiply
|
|
*/
|
|
|
|
muln(b: number): BN;
|
|
/**
|
|
* @description multiply
|
|
*/
|
|
|
|
imuln(b: number): BN;
|
|
|
|
/**
|
|
* @description square
|
|
*/
|
|
sqr(): BN;
|
|
/**
|
|
* @description square
|
|
*/
|
|
isqr(): BN;
|
|
|
|
/**
|
|
* @description raise `a` to the power of `b`
|
|
*/
|
|
|
|
pow(b: BN): BN;
|
|
|
|
/**
|
|
* @description divide
|
|
*/
|
|
div(b: BN): BN;
|
|
/**
|
|
* @description divide
|
|
*/
|
|
divn(b: number): BN;
|
|
/**
|
|
* @description divide
|
|
*/
|
|
idivn(b: number): BN;
|
|
|
|
/**
|
|
* @description reduct
|
|
*/
|
|
|
|
mod(b: BN): BN;
|
|
/**
|
|
* @description reduct
|
|
*/
|
|
|
|
umod(b: BN): BN;
|
|
/**
|
|
* @description reduct
|
|
*/
|
|
|
|
modn(b: number): BN;
|
|
|
|
/**
|
|
* @description rounded division
|
|
*/
|
|
|
|
divRound(b: BN): BN;
|
|
|
|
/**
|
|
* @description or
|
|
*/
|
|
|
|
or(b: BN): BN;
|
|
/**
|
|
* @description or
|
|
*/
|
|
|
|
ior(b: BN): BN;
|
|
/**
|
|
* @description or
|
|
*/
|
|
|
|
uor(b: BN): BN;
|
|
/**
|
|
* @description or
|
|
*/
|
|
|
|
iuor(b: BN): BN;
|
|
|
|
/**
|
|
* @description and
|
|
*/
|
|
|
|
and(b: BN): BN;
|
|
/**
|
|
* @description and
|
|
*/
|
|
|
|
iand(b: BN): BN;
|
|
/**
|
|
* @description and
|
|
*/
|
|
|
|
uand(b: BN): BN;
|
|
/**
|
|
* @description and
|
|
*/
|
|
|
|
iuand(b: BN): BN;
|
|
/**
|
|
* @description and (NOTE: `andln` is going to be replaced with `andn` in future)
|
|
*/
|
|
|
|
andln(b: number): BN;
|
|
/**
|
|
* @description xor
|
|
*/
|
|
|
|
xor(b: BN): BN;
|
|
|
|
/**
|
|
* @description xor
|
|
*/
|
|
|
|
ixor(b: BN): BN;
|
|
/**
|
|
* @description xor
|
|
*/
|
|
|
|
uxor(b: BN): BN;
|
|
/**
|
|
* @description xor
|
|
*/
|
|
|
|
iuxor(b: BN): BN;
|
|
/**
|
|
* @description set specified bit to 1
|
|
*/
|
|
|
|
setn(b: number): BN;
|
|
/**
|
|
* @description shift left
|
|
*/
|
|
|
|
shln(b: number): BN;
|
|
/**
|
|
* @description shift left
|
|
*/
|
|
|
|
ishln(b: number): BN;
|
|
/**
|
|
* @description shift left
|
|
*/
|
|
|
|
ushln(b: number): BN;
|
|
/**
|
|
* @description shift left
|
|
*/
|
|
|
|
iushln(b: number): BN;
|
|
/**
|
|
* @description shift right
|
|
*/
|
|
|
|
shrn(b: number): BN;
|
|
|
|
/**
|
|
* @description shift right
|
|
*/
|
|
|
|
ishrn(b: number): BN;
|
|
/**
|
|
* @description shift right
|
|
*/
|
|
|
|
ushrn(b: number): BN;
|
|
/**
|
|
* @description shift right
|
|
*/
|
|
|
|
iushrn(b: number): BN;
|
|
/**
|
|
* @description test if specified bit is set
|
|
*/
|
|
|
|
testn(b: number): boolean;
|
|
/**
|
|
* @description clear bits with indexes higher or equal to `b`
|
|
*/
|
|
|
|
maskn(b: number): BN;
|
|
/**
|
|
* @description clear bits with indexes higher or equal to `b`
|
|
*/
|
|
|
|
imaskn(b: number): BN;
|
|
/**
|
|
* @description add `1 << b` to the number
|
|
*/
|
|
|
|
bincn(b: number): BN;
|
|
/**
|
|
* @description not (for the width specified by `w`)
|
|
*/
|
|
|
|
notn(w: number): BN;
|
|
/**
|
|
* @description not (for the width specified by `w`)
|
|
*/
|
|
|
|
inotn(w: number): BN;
|
|
|
|
/**
|
|
* @description GCD
|
|
*/
|
|
|
|
gcd(b: BN): BN;
|
|
/**
|
|
* @description Extended GCD results `({ a: ..., b: ..., gcd: ... })`
|
|
*/
|
|
|
|
egcd(b: BN): { a: BN; b: BN; gcd: BN };
|
|
/**
|
|
* @description inverse `a` modulo `b`
|
|
*/
|
|
|
|
invm(b: BN): BN;
|
|
}
|
|
}
|