@smartledger/bsv 5.5.3 → 6.0.0

package/test/ltp/verify_failclosed.js

@@ -0,0 +1,134 @@
+'use strict'
+
+/* global describe, it */
+
+// Regression guard for the C1–C4 fail-open verification bugs. Before the fix,
+// LTP signature verification returned the ECDSA instance (always truthy) or
+// skipped the JWS check entirely (a `// TODO`), so a forged token verified as
+// valid. These tests feed known-bad signatures/issuers and assert valid===false.
+
+var expect = require('chai').expect
+var bsv = require('../../')
+
+var LTP = bsv.LTP
+var RightToken = LTP.Right
+var Obligation = LTP.Obligation
+
+function newDid () {
+  var key = bsv.PrivateKey.fromRandom()
+  return { key: key, did: 'did:key:' + key.toPublicKey().toString() }
+}
+
+describe('LTP verification fails closed (C1–C4 regression)', function () {
+  it('a genuinely signed right token still verifies as valid', function () {
+    var issuer = newDid()
+    var result = RightToken.prepareRightToken(
+      'EquityShare', issuer.did, issuer.did,
+      { spv: 'spv-001', units: 1000 }, issuer.key, {}
+    )
+    expect(result.success).to.equal(true)
+    var v = RightToken.prepareRightTokenVerification(result.rightToken, {})
+    expect(v.verification.valid, JSON.stringify(v.verification.errors)).to.equal(true)
+  })
+
+  it('a tampered JWS signature is rejected (C4)', function () {
+    var issuer = newDid()
+    var result = RightToken.prepareRightToken(
+      'EquityShare', issuer.did, issuer.did, { spv: 'x' }, issuer.key, {}
+    )
+    var token = result.rightToken
+    // Flip the signature: replace it with a signature over different data by a
+    // different key, re-encoded as a valid-looking JWS.
+    var attacker = newDid()
+    var parts = token.proof.jws.split('.')
+    var bogusSig = bsv.crypto.ECDSA.sign(
+      bsv.crypto.Hash.sha256(Buffer.from('not the token')), attacker.key
+    )
+    token.proof.jws = parts[0] + '.' + parts[1] + '.' + bogusSig.toDER().toString('base64url')
+
+    var v = RightToken.prepareRightTokenVerification(token, {})
+    expect(v.verification.valid).to.equal(false)
+  })
+
+  it('a token re-signed by an attacker but attributed to the victim issuer is rejected (C4 binding)', function () {
+    var victim = newDid()
+    var attacker = newDid()
+    var result = RightToken.prepareRightToken(
+      'PropertyTitle', victim.did, victim.did, { parcel: '1 Main' }, victim.key, {}
+    )
+    var token = result.rightToken
+    // Attacker re-signs the exact token hash with THEIR key, but leaves issuer =
+    // victim. Verification must bind to the victim issuer key and reject.
+    var sig = bsv.crypto.ECDSA.sign(
+      bsv.crypto.Hash.sha256(Buffer.from(RightToken._canonicalizeToken(token))), attacker.key
+    )
+    var parts = token.proof.jws.split('.')
+    token.proof.jws = parts[0] + '.' + parts[1] + '.' + sig.toDER().toString('base64url')
+
+    var v = RightToken.prepareRightTokenVerification(token, {})
+    expect(v.verification.valid).to.equal(false)
+  })
+
+  it('prepareRightTokenTransfer rejects a transfer signed by a non-owner (ownership binding)', function () {
+    var owner = newDid()
+    var attacker = newDid()
+    var res = RightToken.prepareRightToken(
+      'EquityShare', owner.did, owner.did, { spv: 't-1' }, owner.key, {}
+    )
+    var token = res.rightToken
+    // Attacker tries to transfer a token they do not own → must be refused.
+    var bad = RightToken.prepareRightTokenTransfer(token, attacker.did, attacker.key, {})
+    expect(bad.success).to.equal(false)
+    // The genuine owner can transfer.
+    var good = RightToken.prepareRightTokenTransfer(token, attacker.did, owner.key, {})
+    expect(good.success, JSON.stringify(good.error)).to.equal(true)
+  })
+
+  it('verifyOwnership rejects a signature by the wrong key (C2)', function () {
+    var owner = newDid()
+    var attacker = newDid()
+    var Resolver = require('../../lib/gdaf/did-resolver')
+    var did = 'did:smartledger:' + owner.key.toPublicKey().toString()
+    var msg = 'transfer authorization'
+    // Signature by attacker, checked against owner's DID → must be false.
+    var badSig = bsv.crypto.ECDSA.sign(bsv.crypto.Hash.sha256(Buffer.from(msg)), attacker.key)
+    expect(Resolver.verifyOwnership(did, badSig.toString(), msg)).to.equal(false)
+  })
+
+  it('verifyAnchor refuses to fabricate success without a chain provider (C3)', async function () {
+    var Anchor = require('../../lib/gdaf/smartledger-anchor')
+    var threw = false
+    try {
+      await Anchor.verifyAnchor('deadbeef', 'cafe')
+    } catch (e) {
+      threw = true
+    }
+    expect(threw).to.equal(true)
+  })
+
+  it('a genuinely signed obligation token still verifies as valid', function () {
+    var issuer = newDid()
+    var ob = Obligation.prepareObligationToken(
+      'PaymentObligation', issuer.did, issuer.did, { amount: 1 }, issuer.key, {}
+    )
+    expect(ob.success).to.equal(true)
+    var v = Obligation.prepareObligationVerification(ob.obligationToken, {})
+    expect(v.verification.valid, JSON.stringify(v.verification && v.verification.errors)).to.equal(true)
+  })
+
+  it('a tampered obligation signature is rejected (C4)', function () {
+    var issuer = newDid()
+    var attacker = newDid()
+    var ob = Obligation.prepareObligationToken(
+      'PaymentObligation', issuer.did, issuer.did, { amount: 1 }, issuer.key, {}
+    )
+    var tok = ob.obligationToken
+    var sig = bsv.crypto.ECDSA.sign(
+      bsv.crypto.Hash.sha256(Buffer.from('forged')), attacker.key
+    )
+    var parts = tok.proof.jws.split('.')
+    tok.proof.jws = parts[0] + '.' + parts[1] + '.' + sig.toDER().toString('base64url')
+    var v = Obligation.prepareObligationVerification(tok, {})
+    expect(v.verification.valid).to.equal(false)
+  })
+})

package/test/ordinals/bsv20.js

@@ -0,0 +1,116 @@
+'use strict'
+
+/* global describe, it */
+
+// BSV-20 / BSV-21 fungible-token inscriptions: build/parse round-trips + validation.
+
+require('chai').should()
+var bsv = require('../..')
+var B = bsv.Ordinals.BSV20
+var Ord = bsv.Ordinals
+
+describe('Ordinals BSV-20 fungible tokens', function () {
+  var key = bsv.PrivateKey.fromRandom()
+  var address = key.toAddress()
+
+  it('deploys a v1 ticker token and round-trips through parse', function () {
+    var s = B.buildDeploy({ address: address, tick: 'ORDI', max: '21000000', lim: '1000', dec: 18 })
+    var p = B.parseBsv20(s)
+    p.p.should.equal('bsv-20')
+    p.op.should.equal('deploy')
+    p.tick.should.equal('ORDI')
+    p.max.should.equal('21000000')
+    p.lim.should.equal('1000')
+    p.dec.should.equal('18')
+    // The payload rides in an inscription with the bsv-20 content-type.
+    Ord.parseInscription(s).contentType.should.equal('application/bsv-20')
+    // The base lock is the owner's P2PKH.
+    Ord.parseInscription(s).lock.toHex().should.equal(bsv.Script.buildPublicKeyHashOut(address).toHex())
+  })
+
+  it('mints and transfers a v1 ticker token', function () {
+    var mint = B.parseBsv20(B.buildMint({ address: address, tick: 'ORDI', amt: '1000' }))
+    mint.op.should.equal('mint')
+    mint.tick.should.equal('ORDI')
+    mint.amt.should.equal('1000')
+
+    var xfer = B.parseBsv20(B.buildTransfer({ address: address, tick: 'ORDI', amt: '250' }))
+    xfer.op.should.equal('transfer')
+    xfer.tick.should.equal('ORDI')
+    xfer.amt.should.equal('250')
+  })
+
+  it('deploy+mints a BSV-21 (id-based) token and transfers by id', function () {
+    var dm = B.parseBsv20(B.buildDeployMint({ address: address, amt: '1000000', dec: 8, sym: 'XYZ' }))
+    dm.op.should.equal('deploy+mint')
+    dm.amt.should.equal('1000000')
+    dm.dec.should.equal('8')
+    dm.sym.should.equal('XYZ')
+
+    var id = 'a'.repeat(64) + '_0'
+    var xfer = B.parseBsv20(B.buildTransfer({ address: address, id: id, amt: '5' }))
+    xfer.op.should.equal('transfer')
+    xfer.id.should.equal(id)
+    xfer.amt.should.equal('5')
+    ;(xfer.tick === undefined).should.equal(true)
+  })
+
+  it('preserves integer amounts larger than 2^53 exactly (string, never a JS number)', function () {
+    var huge = '99999999999999999999999999'
+    var p = B.parseBsv20(B.buildMint({ address: address, tick: 'BIG', amt: huge }))
+    p.amt.should.equal(huge)
+  })
+
+  it('accepts numeric amounts and normalizes them to strings', function () {
+    var p = B.parseBsv20(B.buildMint({ address: address, tick: 'NUM', amt: 42 }))
+    p.amt.should.equal('42')
+  })
+
+  it('builds a 1-sat token output', function () {
+    var out = B.createMintOutput({ address: address, tick: 'ORDI', amt: '1' })
+    out.satoshis.should.equal(1)
+    B.isBsv20(out.script).should.equal(true)
+  })
+
+  it('round-trips through hex serialization', function () {
+    var s = B.buildDeploy({ address: address, tick: 'HEX', max: '1000' })
+    var p = B.parseBsv20(s.toHex())
+    p.tick.should.equal('HEX')
+    p.max.should.equal('1000')
+  })
+
+  it('parses a raw JSON string or an already-parsed object', function () {
+    var json = '{"p":"bsv-20","op":"mint","tick":"ORDI","amt":"1"}'
+    B.parseBsv20(json).amt.should.equal('1')
+    B.parseBsv20({ p: 'bsv-20', op: 'mint', tick: 'ORDI', amt: '1' }).op.should.equal('mint')
+  })
+
+  it('isBsv20 is false for a plain inscription and a P2PKH script', function () {
+    var plain = Ord.buildInscription({ address: address, contentType: 'text/plain', content: 'hi' })
+    B.isBsv20(plain).should.equal(false)
+    B.isBsv20(bsv.Script.buildPublicKeyHashOut(address)).should.equal(false)
+    ;(B.parseBsv20(plain) === null).should.equal(true)
+  })
+
+  describe('validation', function () {
+    it('rejects a tick longer than 4 UTF-8 bytes', function () {
+      ;(function () { B.buildDeploy({ address: address, tick: 'TOOLONG', max: '1' }) }).should.throw(/1–4 UTF-8 bytes/)
+    })
+    it('rejects a non-integer / negative amount', function () {
+      ;(function () { B.buildMint({ address: address, tick: 'ORDI', amt: '1.5' }) }).should.throw(/non-negative integer/)
+      ;(function () { B.buildMint({ address: address, tick: 'ORDI', amt: -5 }) }).should.throw(/non-negative integer/)
+    })
+    it('rejects a zero amount for mint/transfer', function () {
+      ;(function () { B.buildMint({ address: address, tick: 'ORDI', amt: '0' }) }).should.throw(/greater than zero/)
+    })
+    it('rejects dec out of the 0…18 range', function () {
+      ;(function () { B.buildDeploy({ address: address, tick: 'ORDI', max: '1', dec: 19 }) }).should.throw(/dec must be/)
+    })
+    it('rejects a malformed BSV-21 id', function () {
+      ;(function () { B.buildTransfer({ address: address, id: 'notanid', amt: '1' }) }).should.throw(/txid.*vout|<txid>/)
+    })
+    it('requires an owner (address or lock)', function () {
+      ;(function () { B.buildMint({ tick: 'ORDI', amt: '1' }) }).should.throw(/address or a lock/)
+    })
+  })
+})

package/test/ordinals/inscription.js

@@ -0,0 +1,71 @@
+'use strict'
+
+/* global describe, it */
+
+// 1Sat Ordinals inscription build/parse round-trip + output construction.
+
+require('chai').should()
+var bsv = require('../..')
+var Ord = bsv.Ordinals
+
+describe('Ordinals inscriptions', function () {
+  var key = bsv.PrivateKey.fromRandom()
+  var address = key.toAddress()
+
+  it('builds a P2PKH inscription and round-trips through parse', function () {
+    var s = Ord.buildInscription({
+      address: address, contentType: 'text/plain', content: 'hello ordinals'
+    })
+    var parsed = Ord.parseInscription(s)
+    parsed.should.be.an('object')
+    parsed.contentType.should.equal('text/plain')
+    parsed.contentText.should.equal('hello ordinals')
+    // The base lock is exactly the P2PKH for the address.
+    parsed.lock.toHex().should.equal(bsv.Script.buildPublicKeyHashOut(address).toHex())
+  })
+
+  it('preserves binary content and content-type exactly', function () {
+    var content = bsv.crypto.Random.getRandomBuffer(64)
+    var s = Ord.buildInscription({ address: address, contentType: 'image/png', content: content })
+    var parsed = Ord.parseInscription(s)
+    parsed.contentType.should.equal('image/png')
+    parsed.content.equals(content).should.equal(true)
+  })
+
+  it('round-trips through hex serialization', function () {
+    var s = Ord.buildInscription({ address: address, contentType: 'application/json', content: '{"a":1}' })
+    var parsed = Ord.parseInscription(s.toHex())
+    parsed.contentText.should.equal('{"a":1}')
+    parsed.contentType.should.equal('application/json')
+  })
+
+  it('accepts a custom base lock script', function () {
+    var lock = bsv.Script.buildPublicKeyHashOut(address)
+    var s = Ord.buildInscription({ lock: lock, contentType: 'text/plain', content: 'x' })
+    Ord.isInscription(s).should.equal(true)
+    Ord.parseInscription(s).lock.toHex().should.equal(lock.toHex())
+  })
+
+  it('isInscription is false for a plain P2PKH script', function () {
+    var p2pkh = bsv.Script.buildPublicKeyHashOut(address)
+    Ord.isInscription(p2pkh).should.equal(false)
+    var isNull = Ord.parseInscription(p2pkh) === null
+    isNull.should.equal(true)
+  })
+
+  it('createInscriptionOutput is a 1-sat output carrying the inscription', function () {
+    var out = Ord.createInscriptionOutput({ address: address, contentType: 'text/plain', content: 'hi' })
+    out.satoshis.should.equal(1)
+    Ord.isInscription(out.script).should.equal(true)
+  })
+
+  it('batchInscriptionOutputs builds one output per item', function () {
+    var outs = Ord.batchInscriptionOutputs([
+      { address: address, contentType: 'text/plain', content: 'a' },
+      { address: address, contentType: 'text/plain', content: 'b' }
+    ])
+    outs.length.should.equal(2)
+    Ord.parseInscription(outs[0].script).contentText.should.equal('a')
+    Ord.parseInscription(outs[1].script).contentText.should.equal('b')
+  })
+})