@alephium/web3 2.0.8 → 3.0.0-test.0

package/src/utils/sign.ts

@@ -16,24 +16,22 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { ec as EC } from 'elliptic'
 import { binToHex, encodeSignature, hexToBinUnsafe, signatureDecode } from '../utils'
 import { KeyType } from '../signer'
-import * as necc from '@noble/secp256k1'
-import { createHash, createHmac } from 'crypto'
+import * as secp from '@noble/secp256k1'
+import { sha256 } from '@noble/hashes/sha256'
+import { hmac } from '@noble/hashes/hmac'
 
-const ec = new EC('secp256k1')
-
-necc.utils.sha256Sync = (...messages: Uint8Array[]): Uint8Array => {
-  const sha256 = createHash('sha256')
-  for (const message of messages) sha256.update(message)
-  return sha256.digest()
+secp.utils.sha256Sync = (...messages: Uint8Array[]): Uint8Array => {
+  const h = sha256.create()
+  for (const message of messages) h.update(message)
+  return h.digest()
 }
 
-necc.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8Array => {
-  const hash = createHmac('sha256', key)
-  messages.forEach((m) => hash.update(m))
-  return Uint8Array.from(hash.digest())
+secp.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8Array => {
+  const h = hmac.create(sha256, key)
+  for (const message of messages) h.update(message)
+  return h.digest()
 }
 
 function checkKeyType(keyType: KeyType) {
@@ -48,11 +46,11 @@ export function sign(hash: string, privateKey: string, _keyType?: KeyType): stri
   checkKeyType(keyType)
 
   if (keyType === 'default' || keyType === 'gl-secp256k1') {
-    const key = ec.keyFromPrivate(privateKey)
-    const signature = key.sign(hash)
-    return encodeSignature(signature)
+    const sig = secp.signSync(hexToBinUnsafe(hash), hexToBinUnsafe(privateKey), { der: false })
+    const signature = secp.Signature.fromCompact(sig)
+    return encodeSignature({ r: signature.r, s: signature.s })
   } else {
-    const signature = necc.schnorr.signSync(hexToBinUnsafe(hash), hexToBinUnsafe(privateKey))
+    const signature = secp.schnorr.signSync(hexToBinUnsafe(hash), hexToBinUnsafe(privateKey))
     return binToHex(signature)
   }
 }
@@ -63,10 +61,11 @@ export function verifySignature(hash: string, publicKey: string, signature: stri
 
   try {
     if (keyType === 'default' || keyType === 'gl-secp256k1') {
-      const key = ec.keyFromPublic(publicKey, 'hex')
-      return key.verify(hash, signatureDecode(ec, signature))
+      const decoded = signatureDecode(signature)
+      const sig = secp.Signature.fromCompact(decoded.r + decoded.s)
+      return secp.verify(sig, hexToBinUnsafe(hash), hexToBinUnsafe(publicKey))
     } else {
-      return necc.schnorr.verifySync(hexToBinUnsafe(signature), hexToBinUnsafe(hash), hexToBinUnsafe(publicKey))
+      return secp.schnorr.verifySync(hexToBinUnsafe(signature), hexToBinUnsafe(hash), hexToBinUnsafe(publicKey))
     }
   } catch (error) {
     return false

package/src/utils/utils.ts

@@ -16,42 +16,31 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { ec as EC, SignatureInput } from 'elliptic'
-import BN from 'bn.js'
+import * as secp256k1 from '@noble/secp256k1'
 import { TOTAL_NUMBER_OF_GROUPS, TOTAL_NUMBER_OF_CHAINS } from '../constants'
 
 export const networkIds = ['mainnet', 'testnet', 'devnet'] as const
 export type NetworkId = (typeof networkIds)[number]
 export type HexString = string
 
-const ec = new EC('secp256k1')
-
-export function encodeSignature(signature: EC.Signature | { r: BN; s: BN }): string {
-  let sNormalized = signature.s
-  if (ec.n && signature.s.cmp(ec.nh) === 1) {
-    sNormalized = ec.n.sub(signature.s)
-  }
-
-  const r = signature.r.toString('hex', 66).slice(2)
-  const s = sNormalized.toString('hex', 66).slice(2)
-  return r + s
+export function encodeSignature(signature: { r: bigint; s: bigint }): string {
+  const sig = new secp256k1.Signature(signature.r, signature.s).normalizeS()
+  return sig.toCompactHex()
 }
 
 export function encodeHexSignature(rHex: string, sHex: string): string {
-  return encodeSignature({ r: new BN(rHex, 'hex'), s: new BN(sHex, 'hex') })
+  return encodeSignature({ r: BigInt('0x' + rHex), s: BigInt('0x' + sHex) })
 }
 
 // the signature should be in hex string format for 64 bytes
-export function signatureDecode(ec: EC, signature: string): SignatureInput {
+export function signatureDecode(signature: string): { r: string; s: string } {
   if (signature.length !== 128) {
     throw new Error('Invalid signature length')
   }
 
-  const sHex = signature.slice(64, 128)
-  const s = new BN(sHex, 'hex')
-  if (ec.n && s.cmp(ec.nh) < 1) {
-    const decoded = { r: signature.slice(0, 64), s: sHex }
-    return decoded
+  const sig = secp256k1.Signature.fromCompact(signature)
+  if (!sig.hasHighS()) {
+    return { r: signature.slice(0, 64), s: signature.slice(64, 128) }
   } else {
     throw new Error('The signature is not normalized')
   }

package/src/utils/webcrypto.ts

@@ -16,12 +16,11 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { webcrypto, randomFillSync } from 'crypto'
-
-const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined'
+// With Node >= 20, globalThis.crypto (including .subtle) is available natively
+// in Node, browsers, and edge runtimes. No polyfills or Node 'crypto' imports needed.
 
 export class WebCrypto {
-  subtle = isBrowser ? globalThis.crypto.subtle : webcrypto ? webcrypto.subtle : crypto.subtle
+  subtle = globalThis.crypto.subtle
 
   public getRandomValues<T extends ArrayBufferView | null>(array: T): T {
     if (!ArrayBuffer.isView(array)) {
@@ -30,12 +29,7 @@ export class WebCrypto {
       )
     }
     const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength)
-
-    if (isBrowser) {
-      globalThis.crypto.getRandomValues(bytes)
-    } else {
-      randomFillSync(bytes)
-    }
+    globalThis.crypto.getRandomValues(bytes)
     return array
   }
 }

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "templates", "src/**/*.test.ts", "src/**/fixtures/*"],
+  "compilerOptions": {
+    "removeComments": true,
+    "sourceMap": true
+  }
+}