@smartledger/bsv 7.1.0 → 7.3.0

package/lib/ordinals/inscription.js

@@ -23,47 +23,118 @@ var ORD = Buffer.from('ord', 'utf8')
 function scriptClass () { return bsv.Script }
 function op () { return bsv.Opcode }
 
+/** Describe a rejected value for an error message, without dumping its contents. */
+function typeName (v) {
+  if (v === null) return 'null'
+  if (v === undefined) return 'undefined'
+  if (Array.isArray(v)) return 'an array'
+  var t = typeof v
+  return (t === 'object' ? 'an ' : 'a ') + t
+}
+
+/**
+ * Coerce a caller-supplied field to bytes.
+ *
+ * Only strings and Buffers are accepted. Everything else is rejected rather than run
+ * through `String(v)`: an inscription is permanent, and stringifying an object writes
+ * the literal text `[object Object]` to the chain, which is never what the caller meant.
+ */
+function toBuf (v, name) {
+  if (Buffer.isBuffer(v)) return v
+  if (typeof v === 'string') return Buffer.from(v, 'utf8')
+  throw new Error(name + ' must be a string or Buffer, got ' + typeName(v))
+}
+
+/** Fields callers reach for when they mean `content`; named back to them on error. */
+var CONTENT_ALIASES = ['data', 'body', 'payload', 'text', 'message']
+
 /** Resolve a base locking script from a Script, an Address, or an address string. */
 function resolveLock (params) {
   var Script = scriptClass()
-  if (params.lock) {
-    if (params.lock instanceof Script) return params.lock
-    if (Buffer.isBuffer(params.lock)) return Script.fromBuffer(params.lock)
-    if (typeof params.lock === 'string') return Script.fromHex(params.lock)
-    throw new Error('lock must be a Script, Buffer, or hex string')
+  var hasLock = params.lock != null
+  var hasAddress = params.address != null
+
+  // `lock` used to win silently. Two different owners in one call is a mistake worth
+  // surfacing, not resolving by precedence.
+  if (hasLock && hasAddress) {
+    throw new Error('buildInscription accepts `lock` or `address`, not both — they name ' +
+      'different owners and one would be silently ignored')
+  }
+
+  if (hasLock) {
+    var lock
+    if (params.lock instanceof Script) lock = params.lock
+    else if (Buffer.isBuffer(params.lock)) lock = Script.fromBuffer(params.lock)
+    else if (typeof params.lock === 'string') lock = Script.fromHex(params.lock)
+    else throw new Error('lock must be a Script, Buffer, or hex string, got ' + typeName(params.lock))
+
+    // An empty base lock leaves nothing but the inert envelope, and the envelope is
+    // skipped at execution — so whatever the spender pushes is the final stack and the
+    // ordinal is anyone-can-spend. Only a caller appending the envelope to a lock it
+    // supplies itself (as ordlock.js does) legitimately wants this.
+    if (!lock.chunks.length && !params.allowEmptyLock) {
+      throw new Error('lock is empty: the inscription would carry no locking script at ' +
+        'all and the ordinal would be spendable by anyone. Pass a real lock, or ' +
+        '{ allowEmptyLock: true } if you are appending this envelope to your own script')
+    }
+    return lock
   }
-  if (params.address) {
+
+  if (hasAddress) {
     var addr = (params.address instanceof bsv.Address)
       ? params.address
       : bsv.Address.fromString(String(params.address))
     return Script.buildPublicKeyHashOut(addr)
   }
-  throw new Error('buildInscription requires an address or a lock script')
-}
 
-function toBuf (v, enc) {
-  if (Buffer.isBuffer(v)) return v
-  if (v == null) return Buffer.alloc(0)
-  return Buffer.from(String(v), enc || 'utf8')
+  throw new Error('buildInscription requires an address or a lock script')
 }
 
 /**
  * Build a 1Sat Ordinals inscription locking script: a base lock followed by the
  * inert `OP_FALSE OP_IF ... OP_ENDIF` envelope carrying the content.
  *
+ * `content` is required. An inscription with no body is a well-formed script that
+ * inscribes nothing, so omitting it throws rather than silently producing one; pass an
+ * explicit `''` if an empty payload is genuinely what you want.
+ *
  * @param {object} params
- * @param {string|Buffer} params.contentType  e.g. 'text/plain', 'image/png'
- * @param {string|Buffer} params.content       the inscription body
- * @param {Script|Buffer|string} [params.lock] base locking script (overrides address)
- * @param {Address|string} [params.address]    P2PKH owner (used if no `lock`)
+ * @param {string|Buffer} params.content        the inscription body (required)
+ * @param {string|Buffer} [params.contentType]  e.g. 'text/plain', 'image/png'.
+ *   Defaults to 'text/plain' for string content; required for Buffer content, which
+ *   carries no hint about what it is.
+ * @param {Script|Buffer|string} [params.lock]  base locking script (mutually exclusive
+ *   with `address`)
+ * @param {Address|string} [params.address]     P2PKH owner (mutually exclusive with `lock`)
+ * @param {boolean} [params.allowEmptyLock]     permit an empty base lock; see resolveLock
  * @returns {Script} the full inscription locking script
  */
 function buildInscription (params) {
   params = params || {}
   var Opcode = op()
   var lock = resolveLock(params)
-  var contentType = toBuf(params.contentType || 'text/plain')
-  var content = toBuf(params.content)
+
+  if (params.content == null) {
+    var alias = CONTENT_ALIASES.filter(function (k) { return params[k] != null })[0]
+    throw new Error('buildInscription requires `content`' +
+      (alias ? ' — received `' + alias + '`, which is not read' : '') +
+      '. Omitting it would inscribe an empty payload; pass content: \'\' if that is intended')
+  }
+  var content = toBuf(params.content, 'content')
+
+  var contentType
+  if (params.contentType == null) {
+    // A Buffer is opaque — defaulting it to text/plain mislabels binary content on a
+    // permanent record, so make the caller declare it.
+    if (Buffer.isBuffer(params.content)) {
+      throw new Error('contentType is required when content is a Buffer (e.g. ' +
+        "'image/png', 'application/octet-stream') — it cannot be inferred from bytes")
+    }
+    contentType = Buffer.from('text/plain', 'utf8')
+  } else {
+    contentType = toBuf(params.contentType, 'contentType')
+    if (!contentType.length) throw new Error('contentType must not be empty')
+  }
 
   // Clone the base lock so we never mutate the caller's Script.
   var s = scriptClass().fromBuffer(lock.toBuffer())
@@ -84,6 +155,14 @@ function chunkIsOp (chunk, opcodenum) {
 
 /**
  * Parse a 1Sat Ordinals inscription out of a locking script.
+ *
+ * The 1Sat spec allows the locking script to be *prepended or appended* to the
+ * envelope ("A locking script (typically P2PKH) is then prepended/appended to the
+ * inscription script, optionally separated by OP_CODESEPARATOR"). `lock` is therefore
+ * the whole script minus the envelope, in script order — not merely what precedes it.
+ * A separating OP_CODESEPARATOR is kept, because it is genuinely part of the script
+ * that runs and affects the sighash.
+ *
  * @param {Script|Buffer|string} script
  * @returns {null|{ contentType: string, content: Buffer, contentText: string, lock: Script }}
  *   null if the script carries no inscription envelope.
@@ -108,16 +187,13 @@ function parseInscription (script) {
   }
   if (start === -1) return null
 
-  // Everything before the envelope is the base lock.
-  var lock = new Script()
-  for (var k = 0; k < start; k++) lock.chunks.push(chunks[k])
-
   // Walk fields after "ord" until OP_ENDIF: OP_1 => content-type, OP_0 => body.
   var contentType = Buffer.alloc(0)
   var content = Buffer.alloc(0)
+  var end = chunks.length // index of OP_ENDIF, or past the end if the envelope is unterminated
   for (var j = start + 3; j < chunks.length; j++) {
     var c = chunks[j]
-    if (chunkIsOp(c, Opcode.OP_ENDIF)) break
+    if (chunkIsOp(c, Opcode.OP_ENDIF)) { end = j; break }
     if (chunkIsOp(c, Opcode.OP_1) && chunks[j + 1] && chunks[j + 1].buf) {
       contentType = chunks[j + 1].buf; j++
     } else if (chunkIsOp(c, Opcode.OP_0) && chunks[j + 1] && chunks[j + 1].buf) {
@@ -125,6 +201,13 @@ function parseInscription (script) {
     }
   }
 
+  // The lock is everything outside the envelope. Taking only what precedes it dropped
+  // the lock entirely for the spec-legal appended form, reporting an owned ordinal as
+  // having no locking script at all.
+  var lock = new Script()
+  for (var k = 0; k < start; k++) lock.chunks.push(chunks[k])
+  for (var m = end + 1; m < chunks.length; m++) lock.chunks.push(chunks[m])
+
   return {
     contentType: contentType.toString('utf8'),
     content: content,
@@ -140,11 +223,18 @@ function isInscription (script) {
 
 /**
  * Build the 1-satoshi Transaction.Output carrying an inscription.
+ * @param {object} params           as buildInscription, plus:
+ * @param {number} [params.satoshis]  defaults to 1 (the 1Sat Ordinals convention)
  * @returns {Transaction.Output}
  */
 function createInscriptionOutput (params) {
   params = params || {}
   var satoshis = params.satoshis != null ? params.satoshis : 1
+  // Output rejects negatives and fractions, but 0 and the string '1' slipped through:
+  // a 0-sat output carries no ordinal at all.
+  if (typeof satoshis !== 'number' || !Number.isInteger(satoshis) || satoshis < 1) {
+    throw new Error('satoshis must be a positive integer (1 for a standard 1Sat ordinal)')
+  }
   return new bsv.Transaction.Output({
     script: buildInscription(params),
     satoshis: satoshis

package/lib/ordinals/ordlock.js

@@ -182,6 +182,7 @@ function buildOrdLock (params) {
   if (params.inscription) {
     var env = inscription.buildInscription({
       lock: new Script(), // envelope only; the covenant above is the real lock
+      allowEmptyLock: true, // ...which is why the empty-lock guard does not apply here
       contentType: params.inscription.contentType,
       content: params.inscription.content
     })
@@ -204,7 +205,19 @@ function splitPayBlob (blob) {
 
 /**
  * Parse an OrdLock listing script into its economic terms. Returns null if `script`
- * is not a recognizable OrdLock (so it doubles as a detector).
+ * is not an OrdLock (so it doubles as a detector).
+ *
+ * The terms are recovered from the script's shape and then **verified by reconstruction**:
+ * the listing is rebuilt from the recovered seller / payment outputs / inscription and must
+ * match the input byte-for-byte. A script that merely wears the same arrangement of opcodes
+ * — without the OP_PUSH_TX covenant that actually binds the payment into `hashOutputs` —
+ * is rejected, so a non-null result means the purchase branch genuinely enforces payment.
+ *
+ * Note this is *this library's* OrdLock. It is semantically the widely-deployed
+ * ordinal-lock pattern (`hash256(destOutput ‖ payOutput ‖ trailingOutputs) == hashOutputs`
+ * under SIGHASH_ALL|ANYONECANPAY), generalized to multiple payment outputs, but it is built
+ * on our OP_PUSH_TX core rather than compiled from the sCrypt contract — so the bytes differ
+ * and listings are not interchangeable with that template.
  *
  * @param {Script|Buffer|string} script
  * @param {object} [opts]  { network }  network for the returned address strings
@@ -268,6 +281,20 @@ function parseOrdLock (script, opts) {
       insc = { contentType: parsedInsc.contentType, content: parsedInsc.content, contentText: parsedInsc.contentText }
     }
 
+    // Everything above recovers terms from the script's SHAPE. Shape alone proves nothing:
+    // a script carrying this arrangement of opcodes but no OP_PUSH_TX covenant enforces no
+    // payment at all, and reporting a seller and a price for it invents a listing that does
+    // not exist. So rebuild the listing from the recovered terms and require it to match
+    // byte-for-byte — the only way to know the purchase branch really binds the payment.
+    var rebuilt = buildOrdLock({
+      seller: sellerPKH,
+      payOutputs: splitPayBlob(payBlob),
+      inscription: parsedInsc
+        ? { contentType: parsedInsc.contentType, content: parsedInsc.content }
+        : undefined
+    })
+    if (rebuilt.toHex() !== s.toHex()) return null
+
     return {
       seller: { pubKeyHash: sellerPKH, address: bsv.Address.fromPublicKeyHash(sellerPKH, network).toString() },
       payOutputs: payOutputs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartledger/bsv",
-  "version": "7.1.0",
+  "version": "7.3.0",
   "description": "🚀 Complete Bitcoin SV development framework with legally-recognizable DID:web + W3C VC-JWT toolkit, Legal Token Protocol (LTP), Global Digital Attestation Framework (GDAF), StatusList2021 revocation, and 16 flexible loading options. Standards-based credentials with ES256/ES256K support, on-chain BSV anchoring, and comprehensive Bitcoin SV API. Perfect for legal tokens, verifiable credentials, DeFi, smart contracts, and secure Bitcoin applications.",
   "author": "SmartLedger Technology <hello@smartledger.technology> (https://smartledger.technology)",
   "homepage": "https://github.com/codenlighten/smartledger-bsv#readme",

package/test/ordinals/bsv20.js

@@ -56,7 +56,9 @@ describe('Ordinals BSV-20 fungible tokens', function () {
   })
 
   it('preserves integer amounts larger than 2^53 exactly (string, never a JS number)', function () {
-    var huge = '99999999999999999999999999'
+    // uint64 max: far beyond 2^53, and the largest amount the spec allows. The value this
+    // used to test (26 digits) exceeded uint64 and would have been burned by an indexer.
+    var huge = '18446744073709551615'
     var p = B.parseBsv20(B.buildMint({ address: address, tick: 'BIG', amt: huge }))
     p.amt.should.equal(huge)
   })
@@ -72,7 +74,7 @@ describe('Ordinals BSV-20 fungible tokens', function () {
     B.parseBsv20(B.buildMint({ address: address, tick: 'ORDI', amt: '007' })).amt.should.equal('7')
     B.parseBsv20(B.buildDeploy({ address: address, tick: 'ORDI', max: '000100' })).max.should.equal('100')
     // canonicalization does not corrupt a huge value
-    var huge = '90000000000000000000000000'
+    var huge = '18446744073709551615'
     B.parseBsv20(B.buildMint({ address: address, tick: 'ORDI', amt: '0' + huge })).amt.should.equal(huge)
   })
 
@@ -123,4 +125,98 @@ describe('Ordinals BSV-20 fungible tokens', function () {
       ;(function () { B.buildMint({ tick: 'ORDI', amt: '1' }) }).should.throw(/address or a lock/)
     })
   })
+
+  // Checked against the BSV-20 / BSV-21 specification at docs.1satordinals.com.
+  describe('specification conformance', function () {
+    var OUTPOINT = '3b31'.repeat(16) + '_0'
+    var UINT64_MAX = '18446744073709551615'
+
+    it('accepts lim: 0, which the spec defines as unlimited', function () {
+      // "lim | No | String | Per-mint limit; 0 or omitted = unlimited"
+      B.parseBsv20(B.buildDeploy({ address: address, tick: 'ORDI', max: '21000000', lim: 0 }))
+        .lim.should.equal('0')
+      B.parseBsv20(B.buildDeploy({ address: address, tick: 'ORDI', max: '21000000', lim: '0' }))
+        .lim.should.equal('0')
+    })
+
+    it('accepts an amount of exactly uint64 max but rejects one above it', function () {
+      // "Amounts in BSV-21: strings representing uint64" — larger values are emitted
+      // happily as JSON and then discarded by indexers, burning the tokens.
+      B.parseBsv20(B.buildDeploy({ address: address, tick: 'ORDI', max: UINT64_MAX }))
+        .max.should.equal(UINT64_MAX)
+      ;(function () {
+        B.buildDeploy({ address: address, tick: 'ORDI', max: '18446744073709551616' })
+      }).should.throw(/exceeds the uint64 maximum/)
+      ;(function () {
+        B.buildMint({ address: address, tick: 'ORDI', amt: '9'.repeat(26) })
+      }).should.throw(/exceeds the uint64 maximum/)
+    })
+
+    it('rejects a numeric amount past 2^53, which is already imprecise', function () {
+      (function () {
+        B.buildMint({ address: address, tick: 'ORDI', amt: 1e17 })
+      }).should.throw(/MAX_SAFE_INTEGER/)
+    })
+
+    it('rejects non-string sym / icon instead of stringifying them', function () {
+      (function () {
+        B.buildDeployMint({ address: address, amt: '100', sym: {} })
+      }).should.throw(/sym must be a string, got an object/)
+      ;(function () {
+        B.buildDeployMint({ address: address, amt: '100', icon: 42 })
+      }).should.throw(/icon must be a string/)
+    })
+
+    it('requires icon to be an outpoint reference, as the spec defines it', function () {
+      (function () {
+        B.buildDeployMint({ address: address, amt: '100', icon: 'https://example.com/i.png' })
+      }).should.throw(/outpoint reference/)
+      B.parseBsv20(B.buildDeployMint({ address: address, amt: '100', icon: OUTPOINT }))
+        .icon.should.equal(OUTPOINT)
+    })
+
+    // parseBsv20/isBsv20 are documented to report VALIDITY. They previously returned any
+    // JSON object carrying p:'bsv-20' and a string op, including payloads no indexer acts on.
+    describe('parseBsv20 enforces the validity it reports', function () {
+      function rejects (label, payload) {
+        it('rejects ' + label, function () {
+          var json = JSON.stringify(payload)
+          B.isBsv20(json).should.equal(false)
+          ;(B.parseBsv20(json) === null).should.equal(true)
+        })
+      }
+      rejects('a transfer with no amount and no token', { p: 'bsv-20', op: 'transfer' })
+      rejects('a mint with no amount', { p: 'bsv-20', op: 'mint', tick: 'ORDI' })
+      rejects('a deploy with no max', { p: 'bsv-20', op: 'deploy', tick: 'ORDI' })
+      rejects('an operation the spec does not define', { p: 'bsv-20', op: 'not-an-op' })
+      rejects('a transfer naming both tick and id', { p: 'bsv-20', op: 'transfer', tick: 'A', id: OUTPOINT, amt: '1' })
+      rejects('an auth carrying amt, which the spec forbids', { p: 'bsv-20', op: 'auth', id: OUTPOINT, amt: '1' })
+      rejects('a deploy+auth carrying amt, which the spec forbids', { p: 'bsv-20', op: 'deploy+auth', amt: '1' })
+      rejects('a ticker longer than 4 bytes', { p: 'bsv-20', op: 'mint', tick: 'TOOLONG', amt: '1' })
+      rejects('a malformed token id', { p: 'bsv-20', op: 'transfer', id: 'nope', amt: '1' })
+      rejects('an amount above uint64', { p: 'bsv-20', op: 'mint', tick: 'A', amt: '9'.repeat(26) })
+      rejects('dec out of range', { p: 'bsv-20', op: 'deploy', tick: 'A', max: '1', dec: '19' })
+
+      it('accepts the spec operations this library does not yet emit', function () {
+        // Reading the chain is not the same as writing it: burn/auth/deploy+auth are valid
+        // BSV-21 and must be recognised even though there is no builder for them yet.
+        B.isBsv20(JSON.stringify({ p: 'bsv-20', op: 'burn', id: OUTPOINT, amt: '5' })).should.equal(true)
+        B.isBsv20(JSON.stringify({ p: 'bsv-20', op: 'auth', id: OUTPOINT })).should.equal(true)
+        B.isBsv20(JSON.stringify({ p: 'bsv-20', op: 'deploy+auth', sym: 'STABLE' })).should.equal(true)
+      })
+
+      it('tolerates a non-canonical on-chain amount when reading', function () {
+        // Our builder emits canonical amounts, but other people's payloads are not ours
+        // to reject over leading zeros.
+        B.isBsv20(JSON.stringify({ p: 'bsv-20', op: 'mint', tick: 'A', amt: '007' })).should.equal(true)
+      })
+
+      it('still round-trips everything this library builds', function () {
+        B.isBsv20(B.buildDeploy({ address: address, tick: 'ORDI', max: '21000000' })).should.equal(true)
+        B.isBsv20(B.buildMint({ address: address, tick: 'ORDI', amt: '1' })).should.equal(true)
+        B.isBsv20(B.buildTransfer({ address: address, id: OUTPOINT, amt: '1' })).should.equal(true)
+        B.isBsv20(B.buildDeployMint({ address: address, amt: '1000' })).should.equal(true)
+      })
+    })
+  })
 })

package/test/ordinals/inscription.js

@@ -68,4 +68,158 @@ describe('Ordinals inscriptions', function () {
     Ord.parseInscription(outs[0].script).contentText.should.equal('a')
     Ord.parseInscription(outs[1].script).contentText.should.equal('b')
   })
+
+  // The 1Sat spec allows the locking script to be prepended OR appended to the
+  // envelope. The parser only ever looked before it, so an appended lock was dropped
+  // and an owned ordinal was reported as carrying no locking script at all.
+  describe('recovers the lock wherever the spec allows it to sit', function () {
+    var p2pkh = bsv.Script.buildPublicKeyHashOut(address)
+
+    function concat () {
+      var out = new bsv.Script()
+      Array.prototype.slice.call(arguments).forEach(function (part) {
+        part.chunks.forEach(function (c) { out.chunks.push(c) })
+      })
+      return out
+    }
+
+    function envelope () {
+      return Ord.buildInscription({
+        lock: new bsv.Script(), allowEmptyLock: true, contentType: 'text/plain', content: 'hello'
+      })
+    }
+
+    it('recovers a lock that precedes the envelope', function () {
+      var parsed = Ord.parseInscription(concat(p2pkh, envelope()))
+      parsed.lock.toHex().should.equal(p2pkh.toHex())
+      parsed.contentText.should.equal('hello')
+    })
+
+    it('recovers a lock that follows the envelope', function () {
+      var parsed = Ord.parseInscription(concat(envelope(), p2pkh))
+      parsed.lock.toHex().should.equal(p2pkh.toHex())
+      parsed.contentText.should.equal('hello')
+    })
+
+    it('keeps a separating OP_CODESEPARATOR, which really does run', function () {
+      var sep = concat(p2pkh, new bsv.Script().add(bsv.Opcode.OP_CODESEPARATOR), envelope())
+      var parsed = Ord.parseInscription(sep)
+      parsed.lock.chunks.length.should.equal(p2pkh.chunks.length + 1)
+      parsed.contentText.should.equal('hello')
+    })
+
+    it('still reports no lock when there genuinely is none', function () {
+      Ord.parseInscription(envelope()).lock.chunks.length.should.equal(0)
+    })
+  })
+
+  // Every case below used to succeed and emit a well-formed script that inscribed
+  // something other than what the caller asked for. An inscription is permanent, so
+  // each one now fails loudly at build time instead of on-chain.
+  describe('rejects arguments that would silently inscribe the wrong thing', function () {
+    it('throws when content is omitted rather than inscribing an empty payload', function () {
+      (function () {
+        Ord.buildInscription({ address: address, contentType: 'text/plain' })
+      }).should.throw(/requires `content`/)
+    })
+
+    it('names the field the caller actually passed', function () {
+      // The real-world report: a wallet whose own builder calls the field `data`.
+      (function () {
+        Ord.buildInscription({ address: address, contentType: 'text/plain', data: 'hello world' })
+      }).should.throw(/received `data`, which is not read/)
+    })
+
+    it('still allows an explicitly empty payload', function () {
+      var s = Ord.buildInscription({ address: address, contentType: 'text/plain', content: '' })
+      Ord.parseInscription(s).content.length.should.equal(0)
+    })
+
+    it('throws rather than stringifying an object into the payload', function () {
+      // String({}) is '[object Object]' — permanent, and never intended.
+      (function () {
+        Ord.buildInscription({ address: address, contentType: 'text/plain', content: { a: 1 } })
+      }).should.throw(/content must be a string or Buffer, got an object/)
+    })
+
+    it('throws on any non-string, non-Buffer content', function () {
+      [42, true, null, ['a'], undefined].forEach(function (v) {
+        (function () {
+          Ord.buildInscription({ address: address, contentType: 'text/plain', content: v })
+        }).should.throw(Error)
+      })
+    })
+
+    it('requires a contentType for Buffer content instead of labelling it text/plain', function () {
+      var png = Buffer.from([0x89, 0x50, 0x4e, 0x47])
+      ;(function () {
+        Ord.buildInscription({ address: address, content: png })
+      }).should.throw(/contentType is required when content is a Buffer/)
+      // Declared explicitly, it builds.
+      var s = Ord.buildInscription({ address: address, contentType: 'image/png', content: png })
+      Ord.parseInscription(s).contentType.should.equal('image/png')
+    })
+
+    it('keeps the text/plain default for string content', function () {
+      var s = Ord.buildInscription({ address: address, content: 'hi' })
+      Ord.parseInscription(s).contentType.should.equal('text/plain')
+    })
+
+    it('throws on an empty or non-string contentType', function () {
+      (function () {
+        Ord.buildInscription({ address: address, contentType: '', content: 'x' })
+      }).should.throw(/contentType must not be empty/)
+      ;(function () {
+        Ord.buildInscription({ address: address, contentType: {}, content: 'x' })
+      }).should.throw(/contentType must be a string or Buffer/)
+    })
+
+    it('throws on an empty base lock, which would be anyone-can-spend', function () {
+      // With no base lock the script is just the inert envelope: OP_FALSE OP_IF skips
+      // to OP_ENDIF, so whatever the spender pushed is the final stack and any spender
+      // succeeds. Proven below rather than asserted.
+      (function () {
+        Ord.buildInscription({ lock: Buffer.alloc(0), contentType: 'text/plain', content: 'x' })
+      }).should.throw(/spendable by anyone/)
+    })
+
+    it('proves the empty-lock script really is anyone-can-spend', function () {
+      var envelope = Ord.buildInscription({
+        lock: new bsv.Script(), allowEmptyLock: true, contentType: 'text/plain', content: 'x'
+      })
+      // An unlocking script from a key unrelated to `address` satisfies it.
+      var unlock = new bsv.Script().add(bsv.Opcode.OP_1)
+      var interp = new bsv.Script.Interpreter()
+      var ok = interp.verify(unlock, envelope, new bsv.Transaction(), 0, 0)
+      ok.should.equal(true)
+    })
+
+    it('permits an empty lock only when the caller opts in', function () {
+      var s = Ord.buildInscription({
+        lock: new bsv.Script(), allowEmptyLock: true, contentType: 'text/plain', content: 'x'
+      })
+      Ord.isInscription(s).should.equal(true)
+    })
+
+    it('throws when both lock and address are given instead of ignoring one', function () {
+      var lock = bsv.Script.buildPublicKeyHashOut(address)
+      var other = bsv.PrivateKey.fromRandom().toAddress()
+      ;(function () {
+        Ord.buildInscription({ lock: lock, address: other, contentType: 'text/plain', content: 'x' })
+      }).should.throw(/not both/)
+    })
+
+    it('rejects a satoshi amount that carries no ordinal', function () {
+      [0, '1', 1.5, -1].forEach(function (v) {
+        (function () {
+          Ord.createInscriptionOutput({
+            address: address, contentType: 'text/plain', content: 'x', satoshis: v
+          })
+        }).should.throw(Error)
+      })
+      Ord.createInscriptionOutput({
+        address: address, contentType: 'text/plain', content: 'x'
+      }).satoshis.should.equal(1)
+    })
+  })
 })

package/test/ordinals/ordlock.js

@@ -549,4 +549,75 @@ describe('Ordinals OrdLock — code-review regressions', function () {
     })
     Ord.parseOrdLock(lock).totalPrice.should.equal(777)
   })
+
+  // parseOrdLock recovers terms from the script's shape. Shape alone proves nothing: a
+  // script wearing the same opcode arrangement without the OP_PUSH_TX covenant enforces no
+  // payment, and reporting a seller and a price for it invents a listing that does not
+  // exist. The terms are therefore verified by rebuilding the listing and comparing bytes.
+  describe('is a verifier, not a shape matcher', function () {
+    var attacker = bsv.PrivateKey.fromBuffer(Buffer.alloc(32, 9))
+
+    // Wears the fingerprint parseOrdLock keys off: a top-level OP_IF with a 20-byte push,
+    // and OP_TOALTSTACK <blob> OP_CAT OP_SWAP in the OP_ELSE branch. Enforces nothing.
+    function fabricatedListing () {
+      var payout = new bsv.Transaction.Output({
+        script: bsv.Script.buildPublicKeyHashOut(attacker.toAddress()),
+        satoshis: 100000000
+      })
+      var s = new bsv.Script()
+      s.add(bsv.Opcode.OP_IF)
+      s.add(attacker.toAddress().hashBuffer)
+      s.add(bsv.Opcode.OP_DROP)
+      s.add(bsv.Opcode.OP_ELSE)
+      s.add(bsv.Opcode.OP_TOALTSTACK)
+      s.add(payout.toBufferWriter().toBuffer())
+      s.add(bsv.Opcode.OP_CAT)
+      s.add(bsv.Opcode.OP_SWAP)
+      s.add(bsv.Opcode.OP_ENDIF)
+      s.add(bsv.Opcode.OP_TRUE)
+      return s
+    }
+
+    it('rejects a fabricated listing that enforces no payment', function () {
+      var fake = fabricatedListing()
+      Ord.isOrdLock(fake).should.equal(false)
+      ;(Ord.parseOrdLock(fake) === null).should.equal(true)
+    })
+
+    it('proves the fabricated listing really is spendable for free', function () {
+      // Without this, the test above only shows we reject *something*.
+      var interp = new bsv.Script.Interpreter()
+      var unlock = new bsv.Script().add(bsv.Opcode.OP_1)
+      var spent = interp.verify(unlock, fabricatedListing(), new bsv.Transaction(), 0, 0)
+      spent.should.equal(true)
+    })
+
+    it('rejects a genuine listing with anything appended', function () {
+      var real = Ord.buildOrdLock({ seller: owner.toAddress(), price: 50000 })
+      var tampered = bsv.Script.fromHex(real.toHex()).add(bsv.Opcode.OP_NOP)
+      Ord.isOrdLock(tampered).should.equal(false)
+    })
+
+    it('still accepts every genuine listing shape', function () {
+      var simple = Ord.buildOrdLock({ seller: owner.toAddress(), price: 50000 })
+      Ord.parseOrdLock(simple).totalPrice.should.equal(50000)
+
+      var withInsc = Ord.buildOrdLock({
+        seller: owner.toAddress(),
+        price: 777,
+        inscription: { contentType: 'text/plain', content: 'for sale' }
+      })
+      var parsed = Ord.parseOrdLock(withInsc)
+      parsed.totalPrice.should.equal(777)
+      parsed.inscription.contentText.should.equal('for sale')
+
+      var multi = Ord.buildOrdLock({
+        seller: owner.toAddress(),
+        price: 1000,
+        royalties: [{ address: attacker.toAddress(), satoshis: 50 }]
+      })
+      Ord.parseOrdLock(multi).payOutputs.length.should.equal(2)
+      Ord.parseOrdLock(multi).totalPrice.should.equal(1050)
+    })
+  })
 })

package/version.js

@@ -1,3 +1,3 @@
 'use strict'
 // GENERATED by scripts/sync-version.js on `npm version` — do not edit.
-module.exports = '7.1.0'
+module.exports = '7.3.0'