@bsv/wallet-toolbox 1.7.16 → 1.7.17

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/ReductionContext.test.ts

@@ -1,321 +0,0 @@
-/* eslint-env jest */
-import BigNumber from '../../primitives/BigNumber'
-import ReductionContext from '../../primitives/ReductionContext'
-import MontgomoryMethod from '../../primitives/MontgomoryMethod'
-import K256 from '../../primitives/K256'
-
-describe('BN.js/Reduction context', function () {
-  const testMethod = (name: string, Method): void => {
-    describe(name + ' method', function () {
-      it('should support add, iadd, sub, isub operations', () => {
-        const p = new BigNumber(257)
-        const m = new Method(p)
-        const a = new BigNumber(123).toRed(m)
-        const b = new BigNumber(231).toRed(m)
-
-        expect(a.redAdd(b).fromRed().toString(10)).toEqual('97')
-        expect(a.redSub(b).fromRed().toString(10)).toEqual('149')
-        expect(b.redSub(a).fromRed().toString(10)).toEqual('108')
-
-        expect(a.clone().redIAdd(b).fromRed().toString(10)).toEqual('97')
-        expect(a.clone().redISub(b).fromRed().toString(10)).toEqual('149')
-        expect(b.clone().redISub(a).fromRed().toString(10)).toEqual('108')
-      })
-
-      it('should support pow and mul operations', () => {
-        const p192 = new BigNumber(
-          'fffffffffffffffffffffffffffffffeffffffffffffffff',
-          16
-        )
-        const m = new Method(p192)
-        const a = new BigNumber(123)
-        const b = new BigNumber(231)
-        const c = a.toRed(m).redMul(b.toRed(m)).fromRed()
-        expect(c.cmp(a.mul(b).mod(p192))).toEqual(0)
-
-        expect(
-          a.toRed(m).redPow(new BigNumber(0)).fromRed().cmp(new BigNumber(1))
-        ).toEqual(0)
-        expect(
-          a.toRed(m).redPow(new BigNumber(3)).fromRed().cmp(a.sqr().mul(a))
-        ).toEqual(0)
-        expect(
-          a.toRed(m).redPow(new BigNumber(4)).fromRed().cmp(a.sqr().sqr())
-        ).toEqual(0)
-        expect(
-          a.toRed(m).redPow(new BigNumber(8)).fromRed().cmp(a.sqr().sqr().sqr())
-        ).toEqual(0)
-        expect(
-          a
-            .toRed(m)
-            .redPow(new BigNumber(9))
-            .fromRed()
-            .cmp(a.sqr().sqr().sqr().mul(a))
-        ).toEqual(0)
-        expect(
-          a
-            .toRed(m)
-            .redPow(new BigNumber(17))
-            .fromRed()
-            .cmp(a.sqr().sqr().sqr().sqr().mul(a))
-        ).toEqual(0)
-        expect(
-          a
-            .toRed(m)
-            .redPow(new BigNumber('deadbeefabbadead', 16))
-            .fromRed()
-            .toString(16)
-        ).toEqual('3aa0e7e304e320b68ef61592bcb00341866d6fa66e11a4d6')
-      })
-
-      it('should sqrtm numbers', () => {
-        let p = new BigNumber(263)
-        let m = new Method(p)
-        let q = new BigNumber(11).toRed(m)
-
-        let qr = q.redSqrt()
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        qr = q.redSqrt()
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        p = new BigNumber(
-          'fffffffffffffffffffffffffffffffeffffffffffffffff',
-          16
-        )
-        m = new Method(p)
-
-        q = new BigNumber(13).toRed(m)
-        qr = q.redSqrt(/* true, p */)
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        qr = q.redSqrt(/* false, p */)
-        expect(qr.redSqr().cmp(q)).toEqual(0)
-
-        // Tonelli-shanks
-        p = new BigNumber(13)
-        m = new Method(p)
-        q = new BigNumber(10).toRed(m)
-        expect(q.redSqrt().fromRed().toString(10)).toEqual('7')
-      })
-
-      it('should invm numbers', function () {
-        const p = new BigNumber(257)
-        const m = new Method(p)
-        const a = new BigNumber(3).toRed(m)
-        const b = a.redInvm()
-        expect(a.redMul(b).fromRed().toString(16)).toEqual('1')
-      })
-
-      it('should invm numbers (regression)', function () {
-        const p = new BigNumber(
-          'ffffffff00000001000000000000000000000000ffffffffffffffffffffffff',
-          16
-        )
-        let a = new BigNumber(
-          'e1d969b8192fbac73ea5b7921896d6a2263d4d4077bb8e5055361d1f7f8163f3',
-          16
-        )
-
-        const m = new Method(p)
-        a = a.toRed(m)
-
-        expect(a.redInvm().fromRed().negative).toEqual(0)
-      })
-
-      it('should imul numbers', function () {
-        const p = new BigNumber(
-          'fffffffffffffffffffffffffffffffeffffffffffffffff',
-          16
-        )
-        const m = new Method(p)
-
-        const a = new BigNumber('deadbeefabbadead', 16)
-        const b = new BigNumber('abbadeadbeefdead', 16)
-        const c = a.mul(b).mod(p)
-
-        expect(a.toRed(m).redIMul(b.toRed(m)).fromRed().toString(16)).toEqual(
-          c.toString(16)
-        )
-      })
-
-      it('should pow(base, 0) == 1', function () {
-        const base = new BigNumber(256).toRed(new ReductionContext('k256'))
-        const exponent = new BigNumber(0)
-        const result = base.redPow(exponent)
-        expect(result.toString()).toEqual('1')
-      })
-
-      it('should shl numbers', function () {
-        const base = new BigNumber(256).toRed(new ReductionContext('k256'))
-        const result = base.redShl(1)
-        expect(result.toString()).toEqual('512')
-      })
-
-      it('should reduce when converting to red', function () {
-        const p = new BigNumber(257)
-        const m = new Method(p)
-        const a = new BigNumber(5).toRed(m)
-
-        expect(() => {
-          const b = a.redISub(new BigNumber(512).toRed(m))
-          b.redISub(new BigNumber(512).toRed(m))
-        }).not.toThrow()
-      })
-
-      it('redNeg and zero value', function () {
-        const a = new BigNumber(0).toRed(new ReductionContext('k256')).redNeg()
-        expect(a.isZero()).toEqual(true)
-      })
-
-      it('should not allow modulus <= 1', function () {
-        expect(() => {
-          return new ReductionContext(new BigNumber(0))
-        }).toThrow(new Error('modulus must be greater than 1'))
-
-        expect(() => {
-          return new ReductionContext(new BigNumber(1))
-        }).toThrow(new Error('modulus must be greater than 1'))
-
-        expect(() => {
-          return new ReductionContext(new BigNumber(2))
-        }).not.toThrow()
-      })
-    })
-  }
-
-  testMethod('Plain', ReductionContext)
-  testMethod('Montgomery', MontgomoryMethod)
-
-  describe('Pseudo-Mersenne Primes', function () {
-    it('should reduce numbers mod k256', function () {
-      const p = new K256()
-
-      expect(p.ireduce(new BigNumber(0xdead)).toString(16)).toEqual('dead')
-      expect(p.ireduce(new BigNumber('deadbeef', 16)).toString(16)).toEqual(
-        'deadbeef'
-      )
-
-      const num = new BigNumber(
-        'fedcba9876543210fedcba9876543210dead' +
-          'fedcba9876543210fedcba9876543210dead',
-        16
-      )
-      let exp = num.mod(p.p).toString(16)
-      expect(p.ireduce(num).toString(16)).toEqual(exp)
-
-      const regr = new BigNumber(
-        'f7e46df64c1815962bf7bc9c56128798' +
-          '3f4fcef9cb1979573163b477eab93959' +
-          '335dfb29ef07a4d835d22aa3b6797760' +
-          '70a8b8f59ba73d56d01a79af9',
-        16
-      )
-      exp = regr.mod(p.p).toString(16)
-
-      expect(p.ireduce(regr).toString(16)).toEqual(exp)
-    })
-
-    it('should not fail to invm number mod k256', function () {
-      let regr2 = new BigNumber(
-        '6c150c4aa9a8cf1934485d40674d4a7cd494675537bda36d49405c5d2c6f496f',
-        16
-      )
-      regr2 = regr2.toRed(new ReductionContext('k256'))
-      expect(regr2.redInvm().redMul(regr2).fromRed().cmpn(1)).toEqual(0)
-    })
-
-    it('should correctly square the number', function () {
-      const p = new K256().p
-      const red = new ReductionContext('k256')
-
-      const n = new BigNumber(
-        '9cd8cb48c3281596139f147c1364a3ed' + 'e88d3f310fdb0eb98c924e599ca1b3c9',
-        16
-      )
-      const expected = n.sqr().mod(p)
-      const actual = n.toRed(red).redSqr().fromRed()
-
-      expect(actual.toString(16)).toEqual(expected.toString(16))
-    })
-
-    it('redISqr should return right result', function () {
-      const n = new BigNumber('30f28939', 16)
-      const actual = n.toRed(new ReductionContext('k256')).redISqr().fromRed()
-      expect(actual.toString(16)).toEqual('95bd93d19520eb1')
-    })
-  })
-
-  it('should avoid 4.1.0 regresion', function () {
-    const bits2int = (obits, q): BigNumber => {
-      let bits
-      if (Buffer.isBuffer(obits)) {
-        bits = new BigNumber(obits.toString('hex'), 16)
-      } else {
-        bits = new BigNumber(obits)
-      }
-      const shift = (obits.length << 3) - q.bitLength()
-      if (shift > 0) {
-        bits.ishrn(shift)
-      }
-      return bits
-    }
-    const t = Buffer.from(
-      'aff1651e4cd6036d57aa8b2a05ccf1a9d5a40166340ecbbdc55' +
-        'be10b568aa0aa3d05ce9a2fcec9df8ed018e29683c6051cb83e' +
-        '46ce31ba4edb045356a8d0d80b',
-      'hex'
-    )
-    const g = new BigNumber(
-      '5c7ff6b06f8f143fe8288433493e4769c4d988ace5be25a0e24809670' +
-        '716c613d7b0cee6932f8faa7c44d2cb24523da53fbe4f6ec3595892d1' +
-        'aa58c4328a06c46a15662e7eaa703a1decf8bbb2d05dbe2eb956c142a' +
-        '338661d10461c0d135472085057f3494309ffa73c611f78b32adbb574' +
-        '0c361c9f35be90997db2014e2ef5aa61782f52abeb8bd6432c4dd097b' +
-        'c5423b285dafb60dc364e8161f4a2a35aca3a10b1c4d203cc76a470a3' +
-        '3afdcbdd92959859abd8b56e1725252d78eac66e71ba9ae3f1dd24871' +
-        '99874393cd4d832186800654760e1e34c09e4d155179f9ec0dc4473f9' +
-        '96bdce6eed1cabed8b6f116f7ad9cf505df0f998e34ab27514b0ffe7',
-      16
-    )
-    const p = new BigNumber(
-      '9db6fb5951b66bb6fe1e140f1d2ce5502374161fd6538df1648218642' +
-        'f0b5c48c8f7a41aadfa187324b87674fa1822b00f1ecf8136943d7c55' +
-        '757264e5a1a44ffe012e9936e00c1d3e9310b01c7d179805d3058b2a9' +
-        'f4bb6f9716bfe6117c6b5b3cc4d9be341104ad4a80ad6c94e005f4b99' +
-        '3e14f091eb51743bf33050c38de235567e1b34c3d6a5c0ceaa1a0f368' +
-        '213c3d19843d0b4b09dcb9fc72d39c8de41f1bf14d4bb4563ca283716' +
-        '21cad3324b6a2d392145bebfac748805236f5ca2fe92b871cd8f9c36d' +
-        '3292b5509ca8caa77a2adfc7bfd77dda6f71125a7456fea153e433256' +
-        'a2261c6a06ed3693797e7995fad5aabbcfbe3eda2741e375404ae25b',
-      16
-    )
-    const q = new BigNumber(
-      'f2c3119374ce76c9356990b465374a17f23f9ed35089bd969f61c6dde' + '9998c1f',
-      16
-    )
-    const k = bits2int(t, q)
-    const expectedR =
-      '89ec4bb1400eccff8e7d9aa515cd1de7803f2daff09693ee7fd1353e' + '90a68307'
-    const r = g.toRed(new MontgomoryMethod(p)).redPow(k).fromRed().mod(q)
-    expect(r.toString(16)).toEqual(expectedR)
-  })
-
-  it('K256.split for 512 bits number should return equal numbers', function () {
-    const red = new ReductionContext('k256')
-    const input = new BigNumber(1).iushln(512).subn(1)
-    expect(input.bitLength()).toEqual(512)
-    const output = new BigNumber(0)
-    red.prime?.split(input, output)
-    expect(input.cmp(output)).toEqual(0)
-  })
-
-  it('imod should change host object', function () {
-    const red = new ReductionContext(new BigNumber(13))
-    const a = new BigNumber(2).toRed(red)
-    const b = new BigNumber(7).toRed(red)
-    const c = a.redIMul(b)
-    expect(a.toNumber()).toEqual(1)
-    expect(c.toNumber()).toEqual(1)
-  })
-})

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/Schnorr.test.ts

@@ -1,284 +0,0 @@
-import Schnorr from '../../primitives/Schnorr'
-import BigNumber from '../../primitives/BigNumber'
-import Curve from '../../primitives/Curve'
-import PrivateKey from '../../primitives/PrivateKey'
-import PublicKey from '../../primitives/PublicKey'
-import Point from '../../primitives/Point'
-
-describe('Schnorr Zero-Knowledge Proof', () => {
-  let schnorr: Schnorr
-  let curve: Curve
-
-  beforeAll(() => {
-    schnorr = new Schnorr()
-    curve = new Curve()
-  })
-
-  it('should verify a valid proof', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, B, S, proof)
-    expect(result).toBe(true)
-  })
-
-  it('should fail verification if proof is tampered (R modified)', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Tamper with R
-    const tamperedR = proof.R.add(curve.g)
-    const tamperedProof = { ...proof, R: tamperedR }
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, B, S, tamperedProof)
-    expect(result).toBe(false)
-  })
-
-  it('should fail verification if proof is tampered (z modified)', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Tamper with z
-    const tamperedZ = proof.z.add(new BigNumber(1)).umod(curve.n)
-    const tamperedProof = { ...proof, z: tamperedZ }
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, B, S, tamperedProof)
-    expect(result).toBe(false)
-  })
-
-  it("should fail verification if proof is tampered (S' modified)", () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Tamper with S'
-    const tamperedSPrime = proof.SPrime.add(curve.g)
-    const tamperedProof = { ...proof, SPrime: tamperedSPrime }
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, B, S, tamperedProof)
-    expect(result).toBe(false)
-  })
-
-  it('should fail verification if inputs are tampered (A modified)', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Tamper with A
-    const tamperedA = A.add(curve.g)
-
-    // Verify proof
-    const result = schnorr.verifyProof(tamperedA, B, S, proof)
-    expect(result).toBe(false)
-  })
-
-  it('should fail verification if inputs are tampered (B modified)', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Tamper with B
-    const tamperedB = B.add(curve.g)
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, tamperedB, S, proof)
-    expect(result).toBe(false)
-  })
-
-  it('should fail verification if inputs are tampered (S modified)', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Tamper with S
-    const tamperedS = S.add(curve.g)
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, B, tamperedS, proof)
-    expect(result).toBe(false)
-  })
-
-  it('should fail verification if using wrong private key', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const wrongA = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof using wrong private key
-    const proof = schnorr.generateProof(wrongA, A, B, S)
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, B, S, proof)
-    expect(result).toBe(false)
-  })
-
-  it('should fail verification if using wrong public key', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-    const wrongB = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-    const wrongBPublic = wrongB.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Verify proof with wrong B
-    const result = schnorr.verifyProof(A, wrongBPublic, S, proof)
-    expect(result).toBe(false)
-  })
-
-  it('should fail verification if shared secret S is incorrect', () => {
-    // Generate private keys
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Intentionally compute incorrect shared secret
-    const S = B.mul(a).add(curve.g)
-
-    // Generate proof with correct S
-    const proof = schnorr.generateProof(a, A, B, B.mul(a))
-
-    // Verify proof with incorrect S
-    const result = schnorr.verifyProof(A, B, S, proof)
-    expect(result).toBe(false)
-  })
-
-  it('should verify a valid proof with fixed keys', () => {
-    // Use fixed private keys for determinism
-    const a = new PrivateKey(
-      new BigNumber(
-        '123456789abcdef123456789abcdef123456789abcdef123456789abcdef',
-        16
-      )
-    )
-    const b = new PrivateKey(
-      new BigNumber(
-        'abcdef123456789abcdef123456789abcdef123456789abcdef123456789',
-        16
-      )
-    )
-
-    // Compute public keys
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-
-    // Compute shared secret S = B * a
-    const S = B.mul(a)
-
-    // Generate proof
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    // Verify proof
-    const result = schnorr.verifyProof(A, B, S, proof)
-    expect(result).toBe(true)
-  })
-
-  it('should throw an error if inputs are invalid', () => {
-    const a = PrivateKey.fromRandom()
-    const b = PrivateKey.fromRandom()
-    const A = a.toPublicKey()
-    const B = b.toPublicKey()
-    const S = B.mul(a)
-    const proof = schnorr.generateProof(a, A, B, S)
-
-    expect(() => schnorr.verifyProof(null as unknown as PublicKey, B, S, proof)).toThrow()
-    expect(() => schnorr.verifyProof(A, null as unknown as PublicKey, S, proof)).toThrow()
-    expect(() => schnorr.verifyProof(A, B, null as unknown as PublicKey, proof)).toThrow()
-    expect(() => schnorr.verifyProof(A, B, S, null as unknown as { R: Point, SPrime: Point, z: BigNumber })).toThrow() // ✅ Correct cast
-  })
-})

package/mobile/node_modules/@bsv/sdk/src/primitives/__tests/Secp256r1.test.ts

@@ -1,101 +0,0 @@
-import crypto from 'crypto'
-import Secp256r1 from '../Secp256r1.js'
-import { sha256 } from '../Hash.js'
-
-const curve = new Secp256r1()
-
-const TWO_G =
-  '047cf27b188d034f7e8a52380304b51ac3c08969e277f21b35a60b48fc4766997807775510db8ed040293d9ac69f7430dbba7dade63ce982299e04b79d227873d1'
-const THREE_G =
-  '045ecbe4d1a6330a44c8f7ef951d4bf165e6c6b721efada985fb41661bc6e7fd6c8734640c4998ff7e374b06ce1a64a2ecd82ab036384fb83d9a79b127a27d5032'
-
-const toBase64Url = (hex: string): string => Buffer.from(hex, 'hex').toString('base64url')
-
-describe('Secp256r1', () => {
-  test('base point multiplication matches known coordinates and handles infinity', () => {
-    const twoG = curve.multiplyBase(2n)
-    const threeG = curve.multiplyBase(3n)
-    expect(curve.pointToHex(twoG)).toBe(TWO_G)
-    expect(curve.pointToHex(threeG)).toBe(THREE_G)
-    expect(curve.multiplyBase(curve.n)).toBeNull()
-    expect(curve.multiply(null, 5n)).toBeNull()
-  })
-
-  test('public key generation stays on-curve, supports compression, and rejects bad encodings', () => {
-    const priv = curve.generatePrivateKeyHex()
-    const pub = curve.publicKeyFromPrivate(priv)
-    expect(curve.isOnCurve(pub)).toBe(true)
-    const compressed = curve.pointToHex(pub, true)
-    const roundTrip = curve.pointFromHex(compressed)
-    expect(roundTrip).toEqual(pub)
-    expect(() => curve.pointFromHex('05abcdef')).toThrow()
-    expect(() => curve.pointFromHex('')).toThrow()
-  })
-
-  test('adding inverse points yields infinity', () => {
-    const p = curve.multiplyBase(9n)
-    const neg = { x: p!.x, y: curve.p - p!.y }
-    expect(curve.add(p, neg)).toBeNull()
-    expect(curve.add(null, p)).toEqual(p)
-  })
-
-  test('ECDSA sign and verify round-trip, low-s enforced, rejects malformed inputs', () => {
-    const priv = '1'.repeat(64)
-    const pub = curve.publicKeyFromPrivate(priv)
-    const message = Buffer.from('p256 check')
-    const signature = curve.sign(message, priv)
-    const sVal = BigInt('0x' + signature.s)
-    expect(sVal <= curve.n / 2n).toBe(true)
-    expect(curve.verify(message, signature, pub)).toBe(true)
-    expect(curve.verify(Buffer.from('different'), signature, pub)).toBe(false)
-    const tampered = { r: signature.r, s: signature.s.slice(0, 62) + '00' }
-    expect(curve.verify(message, tampered, pub)).toBe(false)
-    const zeroR = { r: '0'.repeat(64), s: signature.s }
-    expect(curve.verify(message, zeroR, pub)).toBe(false)
-    const zeroS = { r: signature.r, s: '0'.repeat(64) }
-    expect(curve.verify(message, zeroS, pub)).toBe(false)
-    expect(curve.verify(message, signature, '02deadbeef')).toBe(false)
-  })
-
-  test('deterministic nonce is stable across calls and message changes', () => {
-    const priv = '2'.repeat(64)
-    const pub = curve.publicKeyFromPrivate(priv)
-    const message = Buffer.from('deterministic nonce')
-    const sig1 = curve.sign(message, priv)
-    const sig2 = curve.sign(message, priv)
-    expect(sig1).toEqual(sig2)
-    const sig3 = curve.sign(Buffer.from('deterministic nonce v2'), priv)
-    expect(sig3).not.toEqual(sig1)
-    expect(curve.verify(message, sig1, pub)).toBe(true)
-  })
-
-  test('prehashed signing path matches explicit hashing input', () => {
-    const priv = '4'.repeat(64)
-    const pub = curve.publicKeyFromPrivate(priv)
-    const message = Buffer.from('prehashed path')
-    const digest = new Uint8Array(sha256(message))
-    const sig1 = curve.sign(message, priv)
-    const sig2 = curve.sign(digest, priv, { prehashed: true })
-    expect(sig1).toEqual(sig2)
-    expect(curve.verify(digest, sig2, pub, { prehashed: true })).toBe(true)
-  })
-
-  test('signatures interoperate with Node crypto (ieee-p1363 encoding)', () => {
-    const priv = '3'.repeat(64)
-    const pub = curve.publicKeyFromPrivate(priv)
-    const message = Buffer.from('interop check')
-    const signature = curve.sign(message, priv)
-    const sigBuf = Buffer.concat([Buffer.from(signature.r, 'hex'), Buffer.from(signature.s, 'hex')])
-
-    const pubHex = curve.pointToHex(pub)
-    const jwk = {
-      kty: 'EC',
-      crv: 'P-256',
-      x: toBase64Url(pubHex.slice(2, 66)),
-      y: toBase64Url(pubHex.slice(66))
-    }
-
-    const ok = crypto.verify('sha256', message, { key: jwk, format: 'jwk', dsaEncoding: 'ieee-p1363' }, sigBuf)
-    expect(ok).toBe(true)
-  })
-})