Current Folder

This commit is contained in:
Luis Fernando Molina committed 2020-11-20 14:05:59 +01:00
1 parent 8b3382289b
commit cfcada880d
4379 files changed

No files matched your search

+2
View File
@@ -0,0 +1,2 @@
const addon = require('node-gyp-build')(__dirname)
module.exports = require('./lib')(new addon.Secp256k1())
+1
View File
@@ -0,0 +1 @@
module.exports = require('./lib')(require('./lib/elliptic'))
+5
View File
@@ -0,0 +1,5 @@
try {
module.exports = require('./bindings')
} catch (err) {
module.exports = require('./elliptic')
}
+402
View File
@@ -0,0 +1,402 @@
const EC = require('elliptic').ec
const ec = new EC('secp256k1')
const ecparams = ec.curve
// Hack, we can not use bn.js@5, while elliptic uses bn.js@4
// See https://github.com/indutny/elliptic/issues/191#issuecomment-569888758
const BN = ecparams.n.constructor
function loadCompressedPublicKey (first, xbuf) {
let x = new BN(xbuf)
// overflow
if (x.cmp(ecparams.p) >= 0) return null
x = x.toRed(ecparams.red)
// compute corresponding Y
let y = x.redSqr().redIMul(x).redIAdd(ecparams.b).redSqrt()
if ((first === 0x03) !== y.isOdd()) y = y.redNeg()
return ec.keyPair({ pub: { x: x, y: y } })
}
function loadUncompressedPublicKey (first, xbuf, ybuf) {
let x = new BN(xbuf)
let y = new BN(ybuf)
// overflow
if (x.cmp(ecparams.p) >= 0 || y.cmp(ecparams.p) >= 0) return null
x = x.toRed(ecparams.red)
y = y.toRed(ecparams.red)
// is odd flag
if ((first === 0x06 || first === 0x07) && y.isOdd() !== (first === 0x07)) return null
// x*x*x + b = y*y
const x3 = x.redSqr().redIMul(x)
if (!y.redSqr().redISub(x3.redIAdd(ecparams.b)).isZero()) return null
return ec.keyPair({ pub: { x: x, y: y } })
}
function loadPublicKey (pubkey) {
// length should be validated in interface
const first = pubkey[0]
switch (first) {
case 0x02:
case 0x03:
if (pubkey.length !== 33) return null
return loadCompressedPublicKey(first, pubkey.subarray(1, 33))
case 0x04:
case 0x06:
case 0x07:
if (pubkey.length !== 65) return null
return loadUncompressedPublicKey(first, pubkey.subarray(1, 33), pubkey.subarray(33, 65))
default:
return null
}
}
function savePublicKey (output, point) {
const pubkey = point.encode(null, output.length === 33)
// Loop should be faster because we do not need create extra Uint8Array
// output.set(new Uint8Array(pubkey))
for (let i = 0; i < output.length; ++i) output[i] = pubkey[i]
}
module.exports = {
contextRandomize () {
return 0
},
privateKeyVerify (seckey) {
const bn = new BN(seckey)
return bn.cmp(ecparams.n) < 0 && !bn.isZero() ? 0 : 1
},
privateKeyNegate (seckey) {
const bn = new BN(seckey)
const negate = ecparams.n.sub(bn).umod(ecparams.n).toArrayLike(Uint8Array, 'be', 32)
seckey.set(negate)
return 0
},
privateKeyTweakAdd (seckey, tweak) {
const bn = new BN(tweak)
if (bn.cmp(ecparams.n) >= 0) return 1
bn.iadd(new BN(seckey))
if (bn.cmp(ecparams.n) >= 0) bn.isub(ecparams.n)
if (bn.isZero()) return 1
const tweaked = bn.toArrayLike(Uint8Array, 'be', 32)
seckey.set(tweaked)
return 0
},
privateKeyTweakMul (seckey, tweak) {
let bn = new BN(tweak)
if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1
bn.imul(new BN(seckey))
if (bn.cmp(ecparams.n) >= 0) bn = bn.umod(ecparams.n)
const tweaked = bn.toArrayLike(Uint8Array, 'be', 32)
seckey.set(tweaked)
return 0
},
publicKeyVerify (pubkey) {
const pair = loadPublicKey(pubkey)
return pair === null ? 1 : 0
},
publicKeyCreate (output, seckey) {
const bn = new BN(seckey)
if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1
const point = ec.keyFromPrivate(seckey).getPublic()
savePublicKey(output, point)
return 0
},
publicKeyConvert (output, pubkey) {
const pair = loadPublicKey(pubkey)
if (pair === null) return 1
const point = pair.getPublic()
savePublicKey(output, point)
return 0
},
publicKeyNegate (output, pubkey) {
const pair = loadPublicKey(pubkey)
if (pair === null) return 1
const point = pair.getPublic()
point.y = point.y.redNeg()
savePublicKey(output, point)
return 0
},
publicKeyCombine (output, pubkeys) {
const pairs = new Array(pubkeys.length)
for (let i = 0; i < pubkeys.length; ++i) {
pairs[i] = loadPublicKey(pubkeys[i])
if (pairs[i] === null) return 1
}
let point = pairs[0].getPublic()
for (let i = 1; i < pairs.length; ++i) point = point.add(pairs[i].pub)
if (point.isInfinity()) return 2
savePublicKey(output, point)
return 0
},
publicKeyTweakAdd (output, pubkey, tweak) {
const pair = loadPublicKey(pubkey)
if (pair === null) return 1
tweak = new BN(tweak)
if (tweak.cmp(ecparams.n) >= 0) return 2
const point = pair.getPublic().add(ecparams.g.mul(tweak))
if (point.isInfinity()) return 2
savePublicKey(output, point)
return 0
},
publicKeyTweakMul (output, pubkey, tweak) {
const pair = loadPublicKey(pubkey)
if (pair === null) return 1
tweak = new BN(tweak)
if (tweak.cmp(ecparams.n) >= 0 || tweak.isZero()) return 2
const point = pair.getPublic().mul(tweak)
savePublicKey(output, point)
return 0
},
signatureNormalize (sig) {
const r = new BN(sig.subarray(0, 32))
const s = new BN(sig.subarray(32, 64))
if (r.cmp(ecparams.n) >= 0 || s.cmp(ecparams.n) >= 0) return 1
if (s.cmp(ec.nh) === 1) {
sig.set(ecparams.n.sub(s).toArrayLike(Uint8Array, 'be', 32), 32)
}
return 0
},
// Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js
// Adapted for Uint8Array instead Buffer
signatureExport (obj, sig) {
const sigR = sig.subarray(0, 32)
const sigS = sig.subarray(32, 64)
if (new BN(sigR).cmp(ecparams.n) >= 0) return 1
if (new BN(sigS).cmp(ecparams.n) >= 0) return 1
const { output } = obj
// Prepare R
let r = output.subarray(4, 4 + 33)
r[0] = 0x00
r.set(sigR, 1)
let lenR = 33
let posR = 0
for (; lenR > 1 && r[posR] === 0x00 && !(r[posR + 1] & 0x80); --lenR, ++posR);
r = r.subarray(posR)
if (r[0] & 0x80) return 1
if (lenR > 1 && (r[0] === 0x00) && !(r[1] & 0x80)) return 1
// Prepare S
let s = output.subarray(6 + 33, 6 + 33 + 33)
s[0] = 0x00
s.set(sigS, 1)
let lenS = 33
let posS = 0
for (; lenS > 1 && s[posS] === 0x00 && !(s[posS + 1] & 0x80); --lenS, ++posS);
s = s.subarray(posS)
if (s[0] & 0x80) return 1
if (lenS > 1 && (s[0] === 0x00) && !(s[1] & 0x80)) return 1
// Set output length for return
obj.outputlen = 6 + lenR + lenS
// Output in specified format
// 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
output[0] = 0x30
output[1] = obj.outputlen - 2
output[2] = 0x02
output[3] = r.length
output.set(r, 4)
output[4 + lenR] = 0x02
output[5 + lenR] = s.length
output.set(s, 6 + lenR)
return 0
},
// Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js
// Adapted for Uint8Array instead Buffer
signatureImport (output, sig) {
if (sig.length < 8) return 1
if (sig.length > 72) return 1
if (sig[0] !== 0x30) return 1
if (sig[1] !== sig.length - 2) return 1
if (sig[2] !== 0x02) return 1
const lenR = sig[3]
if (lenR === 0) return 1
if (5 + lenR >= sig.length) return 1
if (sig[4 + lenR] !== 0x02) return 1
const lenS = sig[5 + lenR]
if (lenS === 0) return 1
if ((6 + lenR + lenS) !== sig.length) return 1
if (sig[4] & 0x80) return 1
if (lenR > 1 && (sig[4] === 0x00) && !(sig[5] & 0x80)) return 1
if (sig[lenR + 6] & 0x80) return 1
if (lenS > 1 && (sig[lenR + 6] === 0x00) && !(sig[lenR + 7] & 0x80)) return 1
let sigR = sig.subarray(4, 4 + lenR)
if (sigR.length === 33 && sigR[0] === 0x00) sigR = sigR.subarray(1)
if (sigR.length > 32) return 1
let sigS = sig.subarray(6 + lenR)
if (sigS.length === 33 && sigS[0] === 0x00) sigS = sigS.slice(1)
if (sigS.length > 32) throw new Error('S length is too long')
let r = new BN(sigR)
if (r.cmp(ecparams.n) >= 0) r = new BN(0)
let s = new BN(sig.subarray(6 + lenR))
if (s.cmp(ecparams.n) >= 0) s = new BN(0)
output.set(r.toArrayLike(Uint8Array, 'be', 32), 0)
output.set(s.toArrayLike(Uint8Array, 'be', 32), 32)
return 0
},
ecdsaSign (obj, message, seckey, data, noncefn) {
if (noncefn) {
const _noncefn = noncefn
noncefn = (counter) => {
const nonce = _noncefn(message, seckey, null, data, counter)
const isValid = nonce instanceof Uint8Array && nonce.length === 32
if (!isValid) throw new Error('This is the way')
return new BN(nonce)
}
}
const d = new BN(seckey)
if (d.cmp(ecparams.n) >= 0 || d.isZero()) return 1
let sig
try {
sig = ec.sign(message, seckey, { canonical: true, k: noncefn, pers: data })
} catch (err) {
return 1
}
obj.signature.set(sig.r.toArrayLike(Uint8Array, 'be', 32), 0)
obj.signature.set(sig.s.toArrayLike(Uint8Array, 'be', 32), 32)
obj.recid = sig.recoveryParam
return 0
},
ecdsaVerify (sig, msg32, pubkey) {
const sigObj = { r: sig.subarray(0, 32), s: sig.subarray(32, 64) }
const sigr = new BN(sigObj.r)
const sigs = new BN(sigObj.s)
if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1
if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return 3
const pair = loadPublicKey(pubkey)
if (pair === null) return 2
const point = pair.getPublic()
const isValid = ec.verify(msg32, sigObj, point)
return isValid ? 0 : 3
},
ecdsaRecover (output, sig, recid, msg32) {
const sigObj = { r: sig.slice(0, 32), s: sig.slice(32, 64) }
const sigr = new BN(sigObj.r)
const sigs = new BN(sigObj.s)
if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1
if (sigr.isZero() || sigs.isZero()) return 2
// Can throw `throw new Error('Unable to find sencond key candinate');`
let point
try {
point = ec.recoverPubKey(msg32, sigObj, recid)
} catch (err) {
return 2
}
savePublicKey(output, point)
return 0
},
ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
const pair = loadPublicKey(pubkey)
if (pair === null) return 1
const scalar = new BN(seckey)
if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2
const point = pair.getPublic().mul(scalar)
if (hashfn === undefined) {
const data = point.encode(null, true)
const sha256 = ec.hash().update(data).digest()
for (let i = 0; i < 32; ++i) output[i] = sha256[i]
} else {
if (!xbuf) xbuf = new Uint8Array(32)
const x = point.getX().toArray('be', 32)
for (let i = 0; i < 32; ++i) xbuf[i] = x[i]
if (!ybuf) ybuf = new Uint8Array(32)
const y = point.getY().toArray('be', 32)
for (let i = 0; i < 32; ++i) ybuf[i] = y[i]
const hash = hashfn(xbuf, ybuf, data)
const isValid = hash instanceof Uint8Array && hash.length === output.length
if (!isValid) return 2
output.set(hash)
}
return 0
}
}
+336
View File
@@ -0,0 +1,336 @@
const errors = {
IMPOSSIBLE_CASE: 'Impossible case. Please create issue.',
TWEAK_ADD:
'The tweak was out of range or the resulted private key is invalid',
TWEAK_MUL: 'The tweak was out of range or equal to zero',
CONTEXT_RANDOMIZE_UNKNOW: 'Unknow error on context randomization',
SECKEY_INVALID: 'Private Key is invalid',
PUBKEY_PARSE: 'Public Key could not be parsed',
PUBKEY_SERIALIZE: 'Public Key serialization error',
PUBKEY_COMBINE: 'The sum of the public keys is not valid',
SIG_PARSE: 'Signature could not be parsed',
SIGN: 'The nonce generation function failed, or the private key was invalid',
RECOVER: 'Public key could not be recover',
ECDH: 'Scalar was invalid (zero or overflow)'
}
function assert (cond, msg) {
if (!cond) throw new Error(msg)
}
function isUint8Array (name, value, length) {
assert(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`)
if (length !== undefined) {
if (Array.isArray(length)) {
const numbers = length.join(', ')
const msg = `Expected ${name} to be an Uint8Array with length [${numbers}]`
assert(length.includes(value.length), msg)
} else {
const msg = `Expected ${name} to be an Uint8Array with length ${length}`
assert(value.length === length, msg)
}
}
}
function isCompressed (value) {
assert(toTypeString(value) === 'Boolean', 'Expected compressed to be a Boolean')
}
function getAssertedOutput (output = (len) => new Uint8Array(len), length) {
if (typeof output === 'function') output = output(length)
isUint8Array('output', output, length)
return output
}
function toTypeString (value) {
return Object.prototype.toString.call(value).slice(8, -1)
}
module.exports = (secp256k1) => {
return {
contextRandomize (seed) {
assert(
seed === null || seed instanceof Uint8Array,
'Expected seed to be an Uint8Array or null'
)
if (seed !== null) isUint8Array('seed', seed, 32)
switch (secp256k1.contextRandomize(seed)) {
case 1:
throw new Error(errors.CONTEXT_RANDOMIZE_UNKNOW)
}
},
privateKeyVerify (seckey) {
isUint8Array('private key', seckey, 32)
return secp256k1.privateKeyVerify(seckey) === 0
},
privateKeyNegate (seckey) {
isUint8Array('private key', seckey, 32)
switch (secp256k1.privateKeyNegate(seckey)) {
case 0:
return seckey
case 1:
throw new Error(errors.IMPOSSIBLE_CASE)
}
},
privateKeyTweakAdd (seckey, tweak) {
isUint8Array('private key', seckey, 32)
isUint8Array('tweak', tweak, 32)
switch (secp256k1.privateKeyTweakAdd(seckey, tweak)) {
case 0:
return seckey
case 1:
throw new Error(errors.TWEAK_ADD)
}
},
privateKeyTweakMul (seckey, tweak) {
isUint8Array('private key', seckey, 32)
isUint8Array('tweak', tweak, 32)
switch (secp256k1.privateKeyTweakMul(seckey, tweak)) {
case 0:
return seckey
case 1:
throw new Error(errors.TWEAK_MUL)
}
},
publicKeyVerify (pubkey) {
isUint8Array('public key', pubkey, [33, 65])
return secp256k1.publicKeyVerify(pubkey) === 0
},
publicKeyCreate (seckey, compressed = true, output) {
isUint8Array('private key', seckey, 32)
isCompressed(compressed)
output = getAssertedOutput(output, compressed ? 33 : 65)
switch (secp256k1.publicKeyCreate(output, seckey)) {
case 0:
return output
case 1:
throw new Error(errors.SECKEY_INVALID)
case 2:
throw new Error(errors.PUBKEY_SERIALIZE)
}
},
publicKeyConvert (pubkey, compressed = true, output) {
isUint8Array('public key', pubkey, [33, 65])
isCompressed(compressed)
output = getAssertedOutput(output, compressed ? 33 : 65)
switch (secp256k1.publicKeyConvert(output, pubkey)) {
case 0:
return output
case 1:
throw new Error(errors.PUBKEY_PARSE)
case 2:
throw new Error(errors.PUBKEY_SERIALIZE)
}
},
publicKeyNegate (pubkey, compressed = true, output) {
isUint8Array('public key', pubkey, [33, 65])
isCompressed(compressed)
output = getAssertedOutput(output, compressed ? 33 : 65)
switch (secp256k1.publicKeyNegate(output, pubkey)) {
case 0:
return output
case 1:
throw new Error(errors.PUBKEY_PARSE)
case 2:
throw new Error(errors.IMPOSSIBLE_CASE)
case 3:
throw new Error(errors.PUBKEY_SERIALIZE)
}
},
publicKeyCombine (pubkeys, compressed = true, output) {
assert(Array.isArray(pubkeys), 'Expected public keys to be an Array')
assert(pubkeys.length > 0, 'Expected public keys array will have more than zero items')
for (const pubkey of pubkeys) {
isUint8Array('public key', pubkey, [33, 65])
}
isCompressed(compressed)
output = getAssertedOutput(output, compressed ? 33 : 65)
switch (secp256k1.publicKeyCombine(output, pubkeys)) {
case 0:
return output
case 1:
throw new Error(errors.PUBKEY_PARSE)
case 2:
throw new Error(errors.PUBKEY_COMBINE)
case 3:
throw new Error(errors.PUBKEY_SERIALIZE)
}
},
publicKeyTweakAdd (pubkey, tweak, compressed = true, output) {
isUint8Array('public key', pubkey, [33, 65])
isUint8Array('tweak', tweak, 32)
isCompressed(compressed)
output = getAssertedOutput(output, compressed ? 33 : 65)
switch (secp256k1.publicKeyTweakAdd(output, pubkey, tweak)) {
case 0:
return output
case 1:
throw new Error(errors.PUBKEY_PARSE)
case 2:
throw new Error(errors.TWEAK_ADD)
}
},
publicKeyTweakMul (pubkey, tweak, compressed = true, output) {
isUint8Array('public key', pubkey, [33, 65])
isUint8Array('tweak', tweak, 32)
isCompressed(compressed)
output = getAssertedOutput(output, compressed ? 33 : 65)
switch (secp256k1.publicKeyTweakMul(output, pubkey, tweak)) {
case 0:
return output
case 1:
throw new Error(errors.PUBKEY_PARSE)
case 2:
throw new Error(errors.TWEAK_MUL)
}
},
signatureNormalize (sig) {
isUint8Array('signature', sig, 64)
switch (secp256k1.signatureNormalize(sig)) {
case 0:
return sig
case 1:
throw new Error(errors.SIG_PARSE)
}
},
signatureExport (sig, output) {
isUint8Array('signature', sig, 64)
output = getAssertedOutput(output, 72)
const obj = { output, outputlen: 72 }
switch (secp256k1.signatureExport(obj, sig)) {
case 0:
return output.slice(0, obj.outputlen)
case 1:
throw new Error(errors.SIG_PARSE)
case 2:
throw new Error(errors.IMPOSSIBLE_CASE)
}
},
signatureImport (sig, output) {
isUint8Array('signature', sig)
output = getAssertedOutput(output, 64)
switch (secp256k1.signatureImport(output, sig)) {
case 0:
return output
case 1:
throw new Error(errors.SIG_PARSE)
case 2:
throw new Error(errors.IMPOSSIBLE_CASE)
}
},
ecdsaSign (msg32, seckey, options = {}, output) {
isUint8Array('message', msg32, 32)
isUint8Array('private key', seckey, 32)
assert(toTypeString(options) === 'Object', 'Expected options to be an Object')
if (options.data !== undefined) isUint8Array('options.data', options.data)
if (options.noncefn !== undefined) assert(toTypeString(options.noncefn) === 'Function', 'Expected options.noncefn to be a Function')
output = getAssertedOutput(output, 64)
const obj = { signature: output, recid: null }
switch (secp256k1.ecdsaSign(obj, msg32, seckey, options.data, options.noncefn)) {
case 0:
return obj
case 1:
throw new Error(errors.SIGN)
case 2:
throw new Error(errors.IMPOSSIBLE_CASE)
}
},
ecdsaVerify (sig, msg32, pubkey) {
isUint8Array('signature', sig, 64)
isUint8Array('message', msg32, 32)
isUint8Array('public key', pubkey, [33, 65])
switch (secp256k1.ecdsaVerify(sig, msg32, pubkey)) {
case 0:
return true
case 3:
return false
case 1:
throw new Error(errors.SIG_PARSE)
case 2:
throw new Error(errors.PUBKEY_PARSE)
}
},
ecdsaRecover (sig, recid, msg32, compressed = true, output) {
isUint8Array('signature', sig, 64)
assert(
toTypeString(recid) === 'Number' &&
recid >= 0 &&
recid <= 3,
'Expected recovery id to be a Number within interval [0, 3]'
)
isUint8Array('message', msg32, 32)
isCompressed(compressed)
output = getAssertedOutput(output, compressed ? 33 : 65)
switch (secp256k1.ecdsaRecover(output, sig, recid, msg32)) {
case 0:
return output
case 1:
throw new Error(errors.SIG_PARSE)
case 2:
throw new Error(errors.RECOVER)
case 3:
throw new Error(errors.IMPOSSIBLE_CASE)
}
},
ecdh (pubkey, seckey, options = {}, output) {
isUint8Array('public key', pubkey, [33, 65])
isUint8Array('private key', seckey, 32)
assert(toTypeString(options) === 'Object', 'Expected options to be an Object')
if (options.data !== undefined) isUint8Array('options.data', options.data)
if (options.hashfn !== undefined) {
assert(toTypeString(options.hashfn) === 'Function', 'Expected options.hashfn to be a Function')
if (options.xbuf !== undefined) isUint8Array('options.xbuf', options.xbuf, 32)
if (options.ybuf !== undefined) isUint8Array('options.ybuf', options.ybuf, 32)
isUint8Array('output', output)
} else {
output = getAssertedOutput(output, 32)
}
switch (secp256k1.ecdh(output, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {
case 0:
return output
case 1:
throw new Error(errors.PUBKEY_PARSE)
case 2:
throw new Error(errors.ECDH)
}
}
}
}
+47
View File
@@ -0,0 +1,47 @@
{
"name": "secp256k1",
"version": "4.0.2",
"description": "This module provides native bindings to ecdsa secp256k1 functions",
"keywords": [
"ec",
"ecdh",
"ecdsa",
"secp256k1"
],
"bugs": {
"url": "https://github.com/cryptocoinjs/secp256k1-node/issues"
},
"repository": {
"type": "git",
"url": "https://github.com/cryptocoinjs/secp256k1-node.git"
},
"license": "MIT",
"author": "Martin Becze <mjbecze@gmail.com>",
"contributors": [
"Aaron Davis (https://github.com/kumavis)",
"Ian Matyssik (https://github.com/phpb-com)",
"Kagami Hiiragi <kagami@genshiken.org> (http://kagami.genshiken.org/)",
"ethers (https://github.com/ethers)",
"Kirill Fomichev <fanatid@ya.ru> (https://github.com/fanatid)"
],
"main": "./index.js",
"browser": {
"./index.js": "./elliptic.js"
},
"scripts": {
"install": "node-gyp-build || exit 0"
},
"dependencies": {
"elliptic": "^6.5.2",
"node-addon-api": "^2.0.0",
"node-gyp-build": "^4.2.0"
},
"engines": {
"node": ">=10.0.0"
},
"gypfile": true
,"_resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.2.tgz"
,"_integrity": "sha512-UDar4sKvWAksIlfX3xIaQReADn+WFnHvbVujpcbr+9Sf/69odMwy2MUsz5CKLQgX9nsIyrjuxL2imVyoNHa3fg=="
,"_from": "secp256k1@^4.0.1"
}