|
|
@ -1,95 +1,107 @@ |
|
|
(function () { |
|
|
(function () { |
|
|
|
|
|
randomBytes = (length) => self.crypto.getRandomValues(new Uint8Array(length)); |
|
|
randomBytes = length => self.crypto.getRandomValues(new Uint8Array(length)) |
|
|
self.Secp256k1 = exports = {}; |
|
|
self.Secp256k1 = exports = {} |
|
|
|
|
|
|
|
|
|
|
|
function uint256(x, base) { |
|
|
function uint256(x, base) { |
|
|
return new BN(x, base) |
|
|
return new BN(x, base); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function rnd(P) { |
|
|
function rnd(P) { |
|
|
return uint256(randomBytes(32)).umod(P)//TODO red
|
|
|
return uint256(randomBytes(32)).umod(P); //TODO red
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
const A = uint256(0) |
|
|
const A = uint256(0); |
|
|
const B = uint256(7) |
|
|
const B = uint256(7); |
|
|
const GX = uint256("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16) |
|
|
const GX = uint256( |
|
|
const GY = uint256("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16) |
|
|
"79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", |
|
|
const P = uint256("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16) |
|
|
16, |
|
|
const N = uint256("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16) |
|
|
); |
|
|
|
|
|
const GY = uint256( |
|
|
|
|
|
"483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", |
|
|
|
|
|
16, |
|
|
|
|
|
); |
|
|
|
|
|
const P = uint256( |
|
|
|
|
|
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", |
|
|
|
|
|
16, |
|
|
|
|
|
); |
|
|
|
|
|
const N = uint256( |
|
|
|
|
|
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", |
|
|
|
|
|
16, |
|
|
|
|
|
); |
|
|
//const RED = BN.red(P)
|
|
|
//const RED = BN.red(P)
|
|
|
const _0 = uint256(0) |
|
|
const _0 = uint256(0); |
|
|
const _1 = uint256(1) |
|
|
const _1 = uint256(1); |
|
|
|
|
|
|
|
|
// function for elliptic curve multiplication in jacobian coordinates using Double-and-add method
|
|
|
// function for elliptic curve multiplication in jacobian coordinates using Double-and-add method
|
|
|
function ecmul(_p, _d) { |
|
|
function ecmul(_p, _d) { |
|
|
let R = [_0,_0,_0] |
|
|
let R = [_0, _0, _0]; |
|
|
|
|
|
|
|
|
//return (0,0) if d=0 or (x1,y1)=(0,0)
|
|
|
//return (0,0) if d=0 or (x1,y1)=(0,0)
|
|
|
if (_d == 0 || ((_p[0] == 0) && (_p[1] == 0)) ) { |
|
|
if (_d == 0 || (_p[0] == 0 && _p[1] == 0)) { |
|
|
return R |
|
|
return R; |
|
|
} |
|
|
} |
|
|
let T = [ |
|
|
let T = [ |
|
|
_p[0], //x-coordinate temp
|
|
|
_p[0], //x-coordinate temp
|
|
|
_p[1], //y-coordinate temp
|
|
|
_p[1], //y-coordinate temp
|
|
|
_p[2], //z-coordinate temp
|
|
|
_p[2], //z-coordinate temp
|
|
|
] |
|
|
]; |
|
|
|
|
|
|
|
|
const d = _d.clone() |
|
|
const d = _d.clone(); |
|
|
while (d != 0) { |
|
|
while (d != 0) { |
|
|
if (d.testn(0)) { //if last bit is 1 add T to result
|
|
|
if (d.testn(0)) { |
|
|
R = ecadd(T,R) |
|
|
//if last bit is 1 add T to result
|
|
|
|
|
|
R = ecadd(T, R); |
|
|
} |
|
|
} |
|
|
T = ecdouble(T); //double temporary coordinates
|
|
|
T = ecdouble(T); //double temporary coordinates
|
|
|
d.iushrn(1); //"cut off" last bit
|
|
|
d.iushrn(1); //"cut off" last bit
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return R |
|
|
return R; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function mulmod(a, b, P) { |
|
|
function mulmod(a, b, P) { |
|
|
return a.mul(b).umod(P)//TODO red
|
|
|
return a.mul(b).umod(P); //TODO red
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function addmod(a, b, P) { |
|
|
function addmod(a, b, P) { |
|
|
return a.add(b).umod(P)//TODO red
|
|
|
return a.add(b).umod(P); //TODO red
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function invmod(a, P) { |
|
|
function invmod(a, P) { |
|
|
return a.invm(P)//TODO redq
|
|
|
return a.invm(P); //TODO redq
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function mulG(k) { |
|
|
function mulG(k) { |
|
|
const GinJ = AtoJ(GX, GY) |
|
|
const GinJ = AtoJ(GX, GY); |
|
|
const PUBinJ = ecmul(GinJ, k) |
|
|
const PUBinJ = ecmul(GinJ, k); |
|
|
return JtoA(PUBinJ) |
|
|
return JtoA(PUBinJ); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function assert(cond, msg) { |
|
|
function assert(cond, msg) { |
|
|
if (!cond) { |
|
|
if (!cond) { |
|
|
throw Error("assertion failed: " + msg) |
|
|
throw Error("assertion failed: " + msg); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function ecsign(d, z) { |
|
|
function ecsign(d, z) { |
|
|
assert(d != 0, "d must not be 0") |
|
|
assert(d != 0, "d must not be 0"); |
|
|
assert(z != 0, "z must not be 0") |
|
|
assert(z != 0, "z must not be 0"); |
|
|
while (true) { |
|
|
while (true) { |
|
|
const k = rnd(P) |
|
|
const k = rnd(P); |
|
|
const R = mulG(k) |
|
|
const R = mulG(k); |
|
|
if (R[0] == 0) continue |
|
|
if (R[0] == 0) continue; |
|
|
const s = mulmod(invmod(k, N), addmod(z, mulmod(R[0], d, N), N), N) |
|
|
const s = mulmod(invmod(k, N), addmod(z, mulmod(R[0], d, N), N), N); |
|
|
if (s == 0) continue |
|
|
if (s == 0) continue; |
|
|
//FIXME: why do I need this
|
|
|
//FIXME: why do I need this
|
|
|
if (s.testn(255)) continue |
|
|
if (s.testn(255)) continue; |
|
|
return {r: toHex(R[0]), s: toHex(s), v: R[1].testn(0) ? 1 : 0} |
|
|
return { r: toHex(R[0]), s: toHex(s), v: R[1].testn(0) ? 1 : 0 }; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function JtoA(p) { |
|
|
function JtoA(p) { |
|
|
const zInv = invmod(p[2], P) |
|
|
const zInv = invmod(p[2], P); |
|
|
const zInv2 = mulmod(zInv, zInv, P) |
|
|
const zInv2 = mulmod(zInv, zInv, P); |
|
|
return [mulmod(p[0], zInv2, P), mulmod(p[1], mulmod(zInv, zInv2, P), P)] |
|
|
return [mulmod(p[0], zInv2, P), mulmod(p[1], mulmod(zInv, zInv2, P), P)]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
//point doubling for elliptic curve in jacobian coordinates
|
|
|
//point doubling for elliptic curve in jacobian coordinates
|
|
|
@ -97,100 +109,114 @@ |
|
|
function ecdouble(_p) { |
|
|
function ecdouble(_p) { |
|
|
if (_p[1] == 0) { |
|
|
if (_p[1] == 0) { |
|
|
//return point at infinity
|
|
|
//return point at infinity
|
|
|
return [_1, _1, _0] |
|
|
return [_1, _1, _0]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
const z2 = mulmod(_p[2], _p[2], P) |
|
|
const z2 = mulmod(_p[2], _p[2], P); |
|
|
const m = addmod(mulmod(A, mulmod(z2, z2, P), P), mulmod(uint256(3), mulmod(_p[0], _p[0], P), P), P) |
|
|
const m = addmod( |
|
|
const y2 = mulmod(_p[1], _p[1], P) |
|
|
mulmod(A, mulmod(z2, z2, P), P), |
|
|
const s = mulmod(uint256(4), mulmod(_p[0], y2, P), P) |
|
|
mulmod(uint256(3), mulmod(_p[0], _p[0], P), P), |
|
|
|
|
|
P, |
|
|
|
|
|
); |
|
|
|
|
|
const y2 = mulmod(_p[1], _p[1], P); |
|
|
|
|
|
const s = mulmod(uint256(4), mulmod(_p[0], y2, P), P); |
|
|
|
|
|
|
|
|
const x = addmod(mulmod(m, m, P), negmod(mulmod(s, uint256(2), P), P), P) |
|
|
const x = addmod(mulmod(m, m, P), negmod(mulmod(s, uint256(2), P), P), P); |
|
|
return [ |
|
|
return [ |
|
|
x, |
|
|
x, |
|
|
addmod(mulmod(m, addmod(s, negmod(x, P), P), P), negmod(mulmod(uint256(8), mulmod(y2, y2, P), P), P), P), |
|
|
addmod( |
|
|
mulmod(uint256(2), mulmod(_p[1], _p[2], P), P) |
|
|
mulmod(m, addmod(s, negmod(x, P), P), P), |
|
|
] |
|
|
negmod(mulmod(uint256(8), mulmod(y2, y2, P), P), P), |
|
|
|
|
|
P, |
|
|
|
|
|
), |
|
|
|
|
|
mulmod(uint256(2), mulmod(_p[1], _p[2], P), P), |
|
|
|
|
|
]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function negmod(a, P) { |
|
|
function negmod(a, P) { |
|
|
return P.sub(a) |
|
|
return P.sub(a); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
// point addition for elliptic curve in jacobian coordinates
|
|
|
// point addition for elliptic curve in jacobian coordinates
|
|
|
// formula from https://en.wikibooks.org/wiki/Cryptography/Prime_Curve/Jacobian_Coordinates
|
|
|
// formula from https://en.wikibooks.org/wiki/Cryptography/Prime_Curve/Jacobian_Coordinates
|
|
|
function ecadd(_p, _q) { |
|
|
function ecadd(_p, _q) { |
|
|
if (_q[0] == 0 && _q[1] == 0 && _q[2] == 0) { |
|
|
if (_q[0] == 0 && _q[1] == 0 && _q[2] == 0) { |
|
|
return _p |
|
|
return _p; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
let z2 = mulmod(_q[2], _q[2], P) |
|
|
let z2 = mulmod(_q[2], _q[2], P); |
|
|
const u1 = mulmod(_p[0], z2, P) |
|
|
const u1 = mulmod(_p[0], z2, P); |
|
|
const s1 = mulmod(_p[1], mulmod(z2, _q[2], P), P) |
|
|
const s1 = mulmod(_p[1], mulmod(z2, _q[2], P), P); |
|
|
z2 = mulmod(_p[2], _p[2], P) |
|
|
z2 = mulmod(_p[2], _p[2], P); |
|
|
let u2 = mulmod(_q[0], z2, P) |
|
|
let u2 = mulmod(_q[0], z2, P); |
|
|
let s2 = mulmod(_q[1], mulmod(z2, _p[2], P), P) |
|
|
let s2 = mulmod(_q[1], mulmod(z2, _p[2], P), P); |
|
|
|
|
|
|
|
|
if (u1.eq(u2)) { |
|
|
if (u1.eq(u2)) { |
|
|
if (!s1.eq(s2)) { |
|
|
if (!s1.eq(s2)) { |
|
|
//return point at infinity
|
|
|
//return point at infinity
|
|
|
return [_1, _1, _0] |
|
|
return [_1, _1, _0]; |
|
|
} |
|
|
} else { |
|
|
else { |
|
|
return ecdouble(_p); |
|
|
return ecdouble(_p) |
|
|
|
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
u2 = addmod(u2, negmod(u1, P), P) |
|
|
u2 = addmod(u2, negmod(u1, P), P); |
|
|
z2 = mulmod(u2, u2, P) |
|
|
z2 = mulmod(u2, u2, P); |
|
|
const t2 = mulmod(u1, z2, P) |
|
|
const t2 = mulmod(u1, z2, P); |
|
|
z2 = mulmod(u2, z2, P) |
|
|
z2 = mulmod(u2, z2, P); |
|
|
s2 = addmod(s2, negmod(s1, P), P) |
|
|
s2 = addmod(s2, negmod(s1, P), P); |
|
|
const x = addmod(addmod(mulmod(s2, s2, P), negmod(z2, P), P), negmod(mulmod(uint256(2), t2, P), P), P) |
|
|
const x = addmod( |
|
|
|
|
|
addmod(mulmod(s2, s2, P), negmod(z2, P), P), |
|
|
|
|
|
negmod(mulmod(uint256(2), t2, P), P), |
|
|
|
|
|
P, |
|
|
|
|
|
); |
|
|
return [ |
|
|
return [ |
|
|
x, |
|
|
x, |
|
|
addmod(mulmod(s2, addmod(t2, negmod(x, P), P), P), negmod(mulmod(s1, z2, P), P), P), |
|
|
addmod( |
|
|
mulmod(u2, mulmod(_p[2], _q[2], P), P) |
|
|
mulmod(s2, addmod(t2, negmod(x, P), P), P), |
|
|
] |
|
|
negmod(mulmod(s1, z2, P), P), |
|
|
|
|
|
P, |
|
|
|
|
|
), |
|
|
|
|
|
mulmod(u2, mulmod(_p[2], _q[2], P), P), |
|
|
|
|
|
]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function AtoJ(x, y) { |
|
|
function AtoJ(x, y) { |
|
|
return [ |
|
|
return [uint256(x), uint256(y), _1]; |
|
|
uint256(x), |
|
|
|
|
|
uint256(y), |
|
|
|
|
|
_1 |
|
|
|
|
|
] |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function isValidPoint(x, y) { |
|
|
function isValidPoint(x, y) { |
|
|
const yy = addmod(mulmod(mulmod(x, x, P), x, P), B, P) |
|
|
const yy = addmod(mulmod(mulmod(x, x, P), x, P), B, P); |
|
|
return yy.eq(mulmod(y, y, P)) |
|
|
return yy.eq(mulmod(y, y, P)); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function toHex(bn) { |
|
|
function toHex(bn) { |
|
|
return ('00000000000000000000000000000000000000000000000000000000000000000000000000000000' + bn.toString(16)).slice(-64) |
|
|
return ( |
|
|
|
|
|
"00000000000000000000000000000000000000000000000000000000000000000000000000000000" + |
|
|
|
|
|
bn.toString(16) |
|
|
|
|
|
).slice(-64); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function decompressKey(x, yBit) { |
|
|
function decompressKey(x, yBit) { |
|
|
let redP = BN.red('k256'); |
|
|
let redP = BN.red("k256"); |
|
|
x = x.toRed(redP) |
|
|
x = x.toRed(redP); |
|
|
const y = x.redMul(x).redMul(x).redAdd(B.toRed(redP)).redSqrt() |
|
|
const y = x.redMul(x).redMul(x).redAdd(B.toRed(redP)).redSqrt(); |
|
|
const sign = y.testn(0) |
|
|
const sign = y.testn(0); |
|
|
return (sign != yBit ? y.redNeg() : y).fromRed() |
|
|
return (sign != yBit ? y.redNeg() : y).fromRed(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function generatePublicKeyFromPrivateKeyData(pk) { |
|
|
function generatePublicKeyFromPrivateKeyData(pk) { |
|
|
const p = mulG(pk) |
|
|
const p = mulG(pk); |
|
|
return {x: toHex(p[0]), y: toHex(p[1])} |
|
|
return { x: toHex(p[0]), y: toHex(p[1]) }; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function ecrecover(recId, sigr, sigs, message) { |
|
|
function ecrecover(recId, sigr, sigs, message) { |
|
|
assert(recId >= 0 && recId <= 3, "recId must be 0..3") |
|
|
assert(recId >= 0 && recId <= 3, "recId must be 0..3"); |
|
|
assert(sigr != 0, "sigr must not be 0") |
|
|
assert(sigr != 0, "sigr must not be 0"); |
|
|
assert(sigs != 0, "sigs must not be 0") |
|
|
assert(sigs != 0, "sigs must not be 0"); |
|
|
// 1.0 For j from 0 to h (h == recId here and the loop is outside this function)
|
|
|
// 1.0 For j from 0 to h (h == recId here and the loop is outside this function)
|
|
|
// 1.1 Let x = r + jn
|
|
|
// 1.1 Let x = r + jn
|
|
|
const x = addmod(uint256(sigr), P.muln(recId >> 1), P) |
|
|
const x = addmod(uint256(sigr), P.muln(recId >> 1), P); |
|
|
// 1.2. Convert the integer x to an octet string X of length mlen using the conversion routine
|
|
|
// 1.2. Convert the integer x to an octet string X of length mlen using the conversion routine
|
|
|
// specified in Section 2.3.7, where mlen = ⌈(log2 p)/8⌉ or mlen = ⌈m/8⌉.
|
|
|
// specified in Section 2.3.7, where mlen = ⌈(log2 p)/8⌉ or mlen = ⌈m/8⌉.
|
|
|
// 1.3. Convert the octet string (16 set binary digits)||X to an elliptic curve point R using the
|
|
|
// 1.3. Convert the octet string (16 set binary digits)||X to an elliptic curve point R using the
|
|
|
@ -200,16 +226,16 @@ |
|
|
// More concisely, what these points mean is to use X as a compressed public key.
|
|
|
// More concisely, what these points mean is to use X as a compressed public key.
|
|
|
if (x.gte(P)) { |
|
|
if (x.gte(P)) { |
|
|
// Cannot have point co-ordinates larger than this as everything takes place modulo Q.
|
|
|
// Cannot have point co-ordinates larger than this as everything takes place modulo Q.
|
|
|
return null |
|
|
return null; |
|
|
} |
|
|
} |
|
|
// Compressed keys require you to know an extra bit of data about the y-coord as there are two possibilities.
|
|
|
// Compressed keys require you to know an extra bit of data about the y-coord as there are two possibilities.
|
|
|
// So it's encoded in the recId.
|
|
|
// So it's encoded in the recId.
|
|
|
const y = decompressKey(x, (recId & 1) == 1) |
|
|
const y = decompressKey(x, (recId & 1) == 1); |
|
|
// 1.4. If nR != point at infinity, then do another iteration of Step 1 (callers responsibility).
|
|
|
// 1.4. If nR != point at infinity, then do another iteration of Step 1 (callers responsibility).
|
|
|
// if (!R.mul(N).isInfinity())
|
|
|
// if (!R.mul(N).isInfinity())
|
|
|
// return null
|
|
|
// return null
|
|
|
// 1.5. Compute e from M using Steps 2 and 3 of ECDSA signature verification.
|
|
|
// 1.5. Compute e from M using Steps 2 and 3 of ECDSA signature verification.
|
|
|
const e = uint256(message) |
|
|
const e = uint256(message); |
|
|
// 1.6. For k from 1 to 2 do the following. (loop is outside this function via iterating recId)
|
|
|
// 1.6. For k from 1 to 2 do the following. (loop is outside this function via iterating recId)
|
|
|
// 1.6.1. Compute a candidate public key as:
|
|
|
// 1.6.1. Compute a candidate public key as:
|
|
|
// Q = mi(r) * (sR - eG)
|
|
|
// Q = mi(r) * (sR - eG)
|
|
|
@ -221,36 +247,37 @@ |
|
|
//
|
|
|
//
|
|
|
// We can find the additive inverse by subtracting e from zero then taking the mod. For example the additive
|
|
|
// We can find the additive inverse by subtracting e from zero then taking the mod. For example the additive
|
|
|
// inverse of 3 modulo 11 is 8 because 3 + 8 mod 11 = 0, and -3 mod 11 = 8.
|
|
|
// inverse of 3 modulo 11 is 8 because 3 + 8 mod 11 = 0, and -3 mod 11 = 8.
|
|
|
const eNeg = negmod(e, N) |
|
|
const eNeg = negmod(e, N); |
|
|
const rInv = invmod(sigr, N) |
|
|
const rInv = invmod(sigr, N); |
|
|
const srInv = mulmod(rInv, sigs, N) |
|
|
const srInv = mulmod(rInv, sigs, N); |
|
|
const eNegrInv = mulmod(rInv, eNeg, N) |
|
|
const eNegrInv = mulmod(rInv, eNeg, N); |
|
|
const R = AtoJ(x, y) |
|
|
const R = AtoJ(x, y); |
|
|
const G = AtoJ(GX, GY) |
|
|
const G = AtoJ(GX, GY); |
|
|
const qinJ = ecadd(ecmul(G, eNegrInv), ecmul(R, srInv)) |
|
|
const qinJ = ecadd(ecmul(G, eNegrInv), ecmul(R, srInv)); |
|
|
const p = JtoA(qinJ) |
|
|
const p = JtoA(qinJ); |
|
|
return {x: toHex(p[0]), y: toHex(p[1])} |
|
|
return { x: toHex(p[0]), y: toHex(p[1]) }; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function ecverify (Qx, Qy, sigr, sigs, z) { |
|
|
function ecverify(Qx, Qy, sigr, sigs, z) { |
|
|
if (sigs == 0 || sigr == 0) { |
|
|
if (sigs == 0 || sigr == 0) { |
|
|
return false |
|
|
return false; |
|
|
} |
|
|
} |
|
|
const w = invmod(sigs, N) |
|
|
const w = invmod(sigs, N); |
|
|
const u1 = mulmod(z, w, N) |
|
|
const u1 = mulmod(z, w, N); |
|
|
const u2 = mulmod(sigr, w, N) |
|
|
const u2 = mulmod(sigr, w, N); |
|
|
const Q = AtoJ(Qx, Qy) |
|
|
const Q = AtoJ(Qx, Qy); |
|
|
const G = AtoJ(GX, GY) |
|
|
const G = AtoJ(GX, GY); |
|
|
const RinJ = ecadd(ecmul(G, u1), ecmul(Q, u2)) |
|
|
const RinJ = ecadd(ecmul(G, u1), ecmul(Q, u2)); |
|
|
const r = JtoA(RinJ) |
|
|
const r = JtoA(RinJ); |
|
|
return sigr.eq(r[0]) |
|
|
return sigr.eq(r[0]); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
exports.uint256 = uint256 |
|
|
exports.uint256 = uint256; |
|
|
exports.ecsign = ecsign |
|
|
exports.ecsign = ecsign; |
|
|
exports.ecrecover = ecrecover |
|
|
exports.ecrecover = ecrecover; |
|
|
exports.generatePublicKeyFromPrivateKeyData = generatePublicKeyFromPrivateKeyData |
|
|
exports.generatePublicKeyFromPrivateKeyData = |
|
|
exports.decompressKey = decompressKey |
|
|
generatePublicKeyFromPrivateKeyData; |
|
|
exports.isValidPoint = isValidPoint |
|
|
exports.decompressKey = decompressKey; |
|
|
exports.ecverify = ecverify |
|
|
exports.isValidPoint = isValidPoint; |
|
|
})() |
|
|
exports.ecverify = ecverify; |
|
|
|
|
|
})(); |
|
|
|
Matthew Raymer
1 year ago