@smartledger/bsv 7.2.0 → 7.4.0

package/lib/ordinals/bsv20.js

@@ -21,19 +21,41 @@ var inscription = require('./inscription')
 var CONTENT_TYPE = 'application/bsv-20'
 var MAX_DEC = 18
 
+// "Amounts in BSV-21: strings representing uint64" — amt/max/lim are bounded by 2^64-1.
+// A larger value is emitted happily by JSON but rejected by indexers, burning the tokens.
+var MAX_UINT64 = '18446744073709551615'
+
 /** A non-negative integer string (no sign, no decimal point). */
 function isIntString (v) { return typeof v === 'string' && /^\d+$/.test(v) }
 
+/** True if the CANONICAL decimal string `s` is greater than 2^64-1. */
+function exceedsUint64 (s) {
+  return s.length > MAX_UINT64.length || (s.length === MAX_UINT64.length && s > MAX_UINT64)
+}
+
 /** Normalize an amount-like field to a CANONICAL non-negative integer string (no leading zeros). */
 function normInt (v, name) {
+  var s
   if (typeof v === 'number') {
     if (!Number.isInteger(v) || v < 0) throw new Error(name + ' must be a non-negative integer')
-    return String(v)
+    // Beyond 2^53 a JS number is already an approximation, so String(v) would silently
+    // emit a *different* amount than the caller believes they passed.
+    if (v > Number.MAX_SAFE_INTEGER) {
+      throw new Error(name + ' exceeds Number.MAX_SAFE_INTEGER and would lose precision — ' +
+        'pass it as a string')
+    }
+    s = String(v)
+  } else if (isIntString(v)) {
+    // Strip leading zeros ("007" -> "7", "000" -> "0") so the emitted payload is canonical
+    // and not rejected by indexers that expect canonical decimal integers.
+    s = v.replace(/^0+(?=\d)/, '')
+  } else {
+    throw new Error(name + ' must be a non-negative integer (string or number)')
   }
-  // Strip leading zeros ("007" -> "7", "000" -> "0") so the emitted payload is canonical
-  // and not rejected by indexers that expect canonical decimal integers.
-  if (isIntString(v)) return v.replace(/^0+(?=\d)/, '')
-  throw new Error(name + ' must be a non-negative integer (string or number)')
+  if (exceedsUint64(s)) {
+    throw new Error(name + ' exceeds the uint64 maximum (' + MAX_UINT64 + ')')
+  }
+  return s
 }
 
 /** Normalize a strictly-positive amount (mint/transfer/supply must move > 0). */
@@ -57,14 +79,39 @@ function normDec (dec) {
   return String(d)
 }
 
+var OUTPOINT_RE = /^[0-9a-fA-F]{64}_\d+$/
+
 /** Validate a BSV-21 token id: `<64-hex-txid>_<vout>`. */
 function assertId (id) {
-  if (typeof id !== 'string' || !/^[0-9a-fA-F]{64}_\d+$/.test(id)) {
+  if (typeof id !== 'string' || !OUTPOINT_RE.test(id)) {
     throw new Error('id must be "<txid>_<vout>" (64-hex txid, underscore, output index)')
   }
   return id
 }
 
+/**
+ * Validate a free-text field (`sym`). Rejects non-strings rather than running them through
+ * `String()`, which wrote the literal text `[object Object]` into a permanent payload.
+ */
+function assertText (v, name) {
+  if (typeof v !== 'string') {
+    var t = v === null ? 'null' : Array.isArray(v) ? 'an array' : (typeof v === 'object' ? 'an ' : 'a ') + typeof v
+    throw new Error(name + ' must be a string, got ' + t)
+  }
+  if (!v.length) throw new Error(name + ' must not be empty')
+  return v
+}
+
+/** Validate `icon`, which the spec defines as an outpoint reference (`<txid>_<vout>`). */
+function assertIcon (v) {
+  assertText(v, 'icon')
+  if (!OUTPOINT_RE.test(v)) {
+    throw new Error('icon must be an outpoint reference "<txid>_<vout>" (64-hex txid, ' +
+      'underscore, output index)')
+  }
+  return v
+}
+
 /** Wrap a BSV-20 JSON payload in an inscription locking script (P2PKH owner by default). */
 function buildBsv20 (payload, params) {
   params = params || {}
@@ -84,7 +131,9 @@ function buildBsv20 (payload, params) {
 function buildDeploy (params) {
   params = params || {}
   var p = { p: 'bsv-20', op: 'deploy', tick: assertTick(params.tick), max: normPositive(params.max, 'max') }
-  if (params.lim != null) p.lim = normPositive(params.lim, 'lim')
+  // `lim` is "0 or omitted = unlimited" per the spec, so 0 is a meaningful value here and
+  // must not be rejected the way a zero `max`/`amt` is.
+  if (params.lim != null) p.lim = normInt(params.lim, 'lim')
   if (params.dec != null) p.dec = normDec(params.dec)
   return buildBsv20(p, params)
 }
@@ -94,9 +143,38 @@ function buildDeploy (params) {
  * @param {object} params { tick, amt, address|lock, contentType? }
  * @returns {Script}
  */
+/**
+ * Name the token an operation acts on: `tick` (v1) or `id` (BSV-21), never both.
+ * Passing both used to silently drop the `tick`, which is the wrong token, not a preference.
+ */
+function assignToken (p, params, op) {
+  var hasTick = params.tick != null
+  var hasId = params.id != null
+  if (hasTick && hasId) {
+    throw new Error(op + ' names a token by `tick` (v1) or `id` (BSV-21), not both')
+  }
+  if (!hasTick && !hasId) {
+    throw new Error(op + ' requires `tick` (v1) or `id` (BSV-21)')
+  }
+  if (hasId) p.id = assertId(params.id)
+  else p.tick = assertTick(params.tick)
+  return p
+}
+
+/** Reject `amt` on the operations the spec says must not carry one. */
+function assertNoAmt (params, op) {
+  if (params.amt != null) {
+    throw new Error(op + ' must not carry an amt — the specification forbids it, and a ' +
+      'payload that does is discarded')
+  }
+}
+
 function buildMint (params) {
   params = params || {}
-  var p = { p: 'bsv-20', op: 'mint', tick: assertTick(params.tick), amt: normPositive(params.amt, 'amt') }
+  // `{p, op, tick|id, amt}` — the token first, then the amount.
+  var p = { p: 'bsv-20', op: 'mint' }
+  assignToken(p, params, 'mint')
+  p.amt = normPositive(params.amt, 'amt')
   return buildBsv20(p, params)
 }
 
@@ -108,8 +186,63 @@ function buildMint (params) {
 function buildTransfer (params) {
   params = params || {}
   var p = { p: 'bsv-20', op: 'transfer', amt: normPositive(params.amt, 'amt') }
-  if (params.id != null) p.id = assertId(params.id)
-  else p.tick = assertTick(params.tick)
+  assignToken(p, params, 'transfer')
+  return buildBsv20(p, params)
+}
+
+/**
+ * Burn an amount of a BSV-21 token: `{p, op:'burn', id, amt}`.
+ *
+ * BSV-21 (id-based) only — the specification defines `burn` under BSV-21, so there is no
+ * ticker form. To retire v1 supply, transfer it to an unspendable output instead.
+ *
+ * @param {object} params { id, amt, address|lock, contentType? }
+ * @returns {Script}
+ */
+function buildBurn (params) {
+  params = params || {}
+  if (params.tick != null) {
+    throw new Error('burn is a BSV-21 operation and names its token by `id` (<txid>_<vout>), ' +
+      'not `tick`')
+  }
+  var p = { p: 'bsv-20', op: 'burn', id: assertId(params.id), amt: normPositive(params.amt, 'amt') }
+  return buildBsv20(p, params)
+}
+
+/**
+ * Deploy a BSV-21 token under an AUTHORITY rather than a fixed supply:
+ * `{p, op:'deploy+auth', sym?, dec?, icon?}`.
+ *
+ * Unlike `deploy+mint`, no supply is created here — minting happens later via `buildMint`
+ * against this deploy's outpoint, and requires an auth input. The spec is explicit that
+ * `amt` must NOT be present.
+ *
+ * @param {object} params { sym?, dec?, icon?, address|lock, contentType? }
+ * @returns {Script}
+ */
+function buildDeployAuth (params) {
+  params = params || {}
+  assertNoAmt(params, 'deploy+auth')
+  var p = { p: 'bsv-20', op: 'deploy+auth' }
+  if (params.dec != null) p.dec = normDec(params.dec)
+  if (params.sym != null) p.sym = assertText(params.sym, 'sym')
+  if (params.icon != null) p.icon = assertIcon(params.icon)
+  return buildBsv20(p, params)
+}
+
+/**
+ * Mint authority for a BSV-21 token: `{p, op:'auth', id}`.
+ *
+ * The output this locks carries the right to mint the token, and "can be split, combined,
+ * or transferred to delegate minting authority". It carries no amount — `amt` is forbidden.
+ *
+ * @param {object} params { id, address|lock, contentType? }
+ * @returns {Script}
+ */
+function buildAuth (params) {
+  params = params || {}
+  assertNoAmt(params, 'auth')
+  var p = { p: 'bsv-20', op: 'auth', id: assertId(params.id) }
   return buildBsv20(p, params)
 }
 
@@ -122,8 +255,8 @@ function buildDeployMint (params) {
   params = params || {}
   var p = { p: 'bsv-20', op: 'deploy+mint', amt: normPositive(params.amt, 'amt') }
   if (params.dec != null) p.dec = normDec(params.dec)
-  if (params.sym != null) p.sym = String(params.sym)
-  if (params.icon != null) p.icon = String(params.icon)
+  if (params.sym != null) p.sym = assertText(params.sym, 'sym')
+  if (params.icon != null) p.icon = assertIcon(params.icon)
   return buildBsv20(p, params)
 }
 
@@ -137,6 +270,9 @@ function createDeployOutput (params) { return outputFor(buildDeploy(params), par
 function createMintOutput (params) { return outputFor(buildMint(params), params && params.satoshis) }
 function createTransferOutput (params) { return outputFor(buildTransfer(params), params && params.satoshis) }
 function createDeployMintOutput (params) { return outputFor(buildDeployMint(params), params && params.satoshis) }
+function createBurnOutput (params) { return outputFor(buildBurn(params), params && params.satoshis) }
+function createDeployAuthOutput (params) { return outputFor(buildDeployAuth(params), params && params.satoshis) }
+function createAuthOutput (params) { return outputFor(buildAuth(params), params && params.satoshis) }
 
 /** Extract the JSON body from a locking script, a JSON string, a Buffer, or an object. */
 function bodyOf (input) {
@@ -149,10 +285,69 @@ function bodyOf (input) {
   return insc ? insc.contentText : null
 }
 
+/**
+ * Required-field rules per operation, from the BSV-20 / BSV-21 specification.
+ *
+ * `tickOrId` means the operation must carry exactly one of `tick` (v1) or `id` (v2/BSV-21).
+ * `noAmt` marks the operations the spec says must NOT carry an `amt` at all.
+ */
+var OP_RULES = {
+  deploy: { need: ['tick', 'max'] },
+  mint: { need: ['amt'], tickOrId: true },
+  transfer: { need: ['amt'], tickOrId: true },
+  'deploy+mint': { need: ['amt'] },
+  'deploy+auth': { need: [], noAmt: true },
+  auth: { need: ['id'], noAmt: true },
+  burn: { need: ['id', 'amt'] }
+}
+
+/**
+ * Is `v` a uint64 amount as it may appear ON CHAIN? Leading zeros are tolerated here even
+ * though the builder emits canonical values: this reads other people's payloads, and a
+ * non-canonical amount is still an amount.
+ */
+function isParsedAmount (v) {
+  var s = typeof v === 'number' ? (Number.isInteger(v) && v >= 0 ? String(v) : null) : (isIntString(v) ? v : null)
+  if (s == null) return false
+  return !exceedsUint64(s.replace(/^0+(?=\d)/, ''))
+}
+
+/** Validate a parsed payload against the spec's per-operation field rules. */
+function isValidPayload (obj) {
+  if (!obj || obj.p !== 'bsv-20' || typeof obj.op !== 'string') return false
+  var rule = OP_RULES[obj.op]
+  if (!rule) return false // unknown operation: we cannot vouch for it
+  for (var i = 0; i < rule.need.length; i++) {
+    if (obj[rule.need[i]] == null) return false
+  }
+  if (rule.tickOrId && (obj.tick == null) === (obj.id == null)) return false
+  if (rule.noAmt && obj.amt != null) return false
+  if (obj.tick != null) {
+    if (typeof obj.tick !== 'string' || !obj.tick.length || Buffer.byteLength(obj.tick, 'utf8') > 4) return false
+  }
+  if (obj.id != null && (typeof obj.id !== 'string' || !OUTPOINT_RE.test(obj.id))) return false
+  var amounts = ['amt', 'max', 'lim']
+  for (var j = 0; j < amounts.length; j++) {
+    if (obj[amounts[j]] != null && !isParsedAmount(obj[amounts[j]])) return false
+  }
+  if (obj.dec != null) {
+    var d = typeof obj.dec === 'string' ? Number(obj.dec) : obj.dec
+    if (!Number.isInteger(d) || d < 0 || d > MAX_DEC) return false
+  }
+  return true
+}
+
 /**
  * Parse a BSV-20 payload from a locking script (Script/Buffer/hex), a JSON string, or an
  * already-parsed object. Returns the payload object (with `p:'bsv-20'`) or null if the
  * input carries no valid BSV-20 inscription.
+ *
+ * "Valid" is enforced, not assumed: the operation must be one the spec defines and must
+ * carry the fields that operation requires, with `tick`/`id`/amount/`dec` well-formed.
+ * A payload this returns is one an indexer will act on; previously any JSON object with
+ * `p: 'bsv-20'` and a string `op` was returned, including `{p:'bsv-20', op:'transfer'}`
+ * with no amount and no token — which an indexer discards.
+ *
  * @returns {null|{ p:'bsv-20', op:string, tick?:string, id?:string, amt?:string, max?:string, lim?:string, dec?:string, sym?:string, icon?:string }}
  */
 function parseBsv20 (input) {
@@ -160,14 +355,13 @@ function parseBsv20 (input) {
     var body = bodyOf(input)
     if (body == null) return null
     var obj = (typeof body === 'object') ? body : JSON.parse(body)
-    if (!obj || obj.p !== 'bsv-20' || typeof obj.op !== 'string') return null
-    return obj
+    return isValidPayload(obj) ? obj : null
   } catch (e) {
     return null
   }
 }
 
-/** True if the input carries a valid BSV-20 inscription. */
+/** True if the input carries a valid BSV-20 inscription (see parseBsv20 for what that means). */
 function isBsv20 (input) { return parseBsv20(input) !== null }
 
 module.exports = {
@@ -176,10 +370,16 @@ module.exports = {
   buildMint: buildMint,
   buildTransfer: buildTransfer,
   buildDeployMint: buildDeployMint,
+  buildBurn: buildBurn,
+  buildDeployAuth: buildDeployAuth,
+  buildAuth: buildAuth,
   createDeployOutput: createDeployOutput,
   createMintOutput: createMintOutput,
   createTransferOutput: createTransferOutput,
   createDeployMintOutput: createDeployMintOutput,
+  createBurnOutput: createBurnOutput,
+  createDeployAuthOutput: createDeployAuthOutput,
+  createAuthOutput: createAuthOutput,
   parseBsv20: parseBsv20,
   isBsv20: isBsv20
 }

package/lib/ordinals/ordlock.js

@@ -205,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
@@ -269,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.2.0",
+  "version": "7.4.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,213 @@ 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)
+        B.isBsv20(B.buildBurn({ address: address, id: OUTPOINT, amt: '1' })).should.equal(true)
+        B.isBsv20(B.buildAuth({ address: address, id: OUTPOINT })).should.equal(true)
+        B.isBsv20(B.buildDeployAuth({ address: address, sym: 'STABLE' })).should.equal(true)
+      })
+    })
+  })
+
+  // BSV-21 authority model: deploy+auth creates no supply, an auth output carries the right
+  // to mint, and mint names its token by `id`. Previously only the fixed-supply deploy+mint
+  // path could be built, so these operations could be read but never written.
+  describe('BSV-21 authority operations', function () {
+    var OUTPOINT = '3b31'.repeat(16) + '_0'
+
+    it('mints by id, which requires an auth input on chain', function () {
+      var p = B.parseBsv20(B.buildMint({ address: address, id: OUTPOINT, amt: '1000000' }))
+      p.op.should.equal('mint')
+      p.id.should.equal(OUTPOINT)
+      p.amt.should.equal('1000000')
+      ;(p.tick === undefined).should.equal(true)
+    })
+
+    it('leaves the v1 ticker mint byte-for-byte unchanged', function () {
+      var p = B.parseBsv20(B.buildMint({ address: address, tick: 'ORDI', amt: '1000' }))
+      JSON.stringify(p).should.equal('{"p":"bsv-20","op":"mint","tick":"ORDI","amt":"1000"}')
+    })
+
+    it('refuses to guess which token an operation means', function () {
+      // Naming both used to silently drop the tick — a different token, not a preference.
+      (function () {
+        B.buildMint({ address: address, tick: 'ORDI', id: OUTPOINT, amt: '1' })
+      }).should.throw(/not both/)
+      ;(function () {
+        B.buildTransfer({ address: address, tick: 'ORDI', id: OUTPOINT, amt: '1' })
+      }).should.throw(/not both/)
+      ;(function () {
+        B.buildMint({ address: address, amt: '1' })
+      }).should.throw(/requires `tick` \(v1\) or `id`/)
+    })
+
+    it('builds a burn', function () {
+      var p = B.parseBsv20(B.buildBurn({ address: address, id: OUTPOINT, amt: '5' }))
+      p.op.should.equal('burn')
+      p.id.should.equal(OUTPOINT)
+      p.amt.should.equal('5')
+    })
+
+    it('rejects a ticker burn, which the spec does not define', function () {
+      (function () {
+        B.buildBurn({ address: address, tick: 'ORDI', amt: '5' })
+      }).should.throw(/BSV-21 operation/)
+    })
+
+    it('builds deploy+auth with no supply', function () {
+      var p = B.parseBsv20(B.buildDeployAuth({ address: address, sym: 'STABLE', dec: 6 }))
+      p.op.should.equal('deploy+auth')
+      p.sym.should.equal('STABLE')
+      p.dec.should.equal('6')
+      ;(p.amt === undefined).should.equal(true)
+      // Every field is optional.
+      B.parseBsv20(B.buildDeployAuth({ address: address })).op.should.equal('deploy+auth')
+    })
+
+    it('builds an auth output carrying no amount', function () {
+      var p = B.parseBsv20(B.buildAuth({ address: address, id: OUTPOINT }))
+      p.op.should.equal('auth')
+      p.id.should.equal(OUTPOINT)
+      ;(p.amt === undefined).should.equal(true)
+    })
+
+    it('refuses to attach an amt where the spec forbids one', function () {
+      (function () {
+        B.buildAuth({ address: address, id: OUTPOINT, amt: '1' })
+      }).should.throw(/must not carry an amt/)
+      ;(function () {
+        B.buildDeployAuth({ address: address, sym: 'X', amt: '1' })
+      }).should.throw(/must not carry an amt/)
+    })
+
+    it('applies the same amount rules as the other operations', function () {
+      (function () {
+        B.buildBurn({ address: address, id: OUTPOINT, amt: '0' })
+      }).should.throw(/greater than zero/)
+      ;(function () {
+        B.buildBurn({ address: address, id: OUTPOINT, amt: '9'.repeat(26) })
+      }).should.throw(/exceeds the uint64 maximum/)
+      ;(function () {
+        B.buildMint({ address: address, id: 'notanid', amt: '1' })
+      }).should.throw(/<txid>/)
+      ;(function () {
+        B.buildDeployAuth({ address: address, sym: {} })
+      }).should.throw(/sym must be a string/)
+    })
+
+    it('builds 1-sat outputs for each new operation', function () {
+      var outs = [
+        B.createBurnOutput({ address: address, id: OUTPOINT, amt: '5' }),
+        B.createAuthOutput({ address: address, id: OUTPOINT }),
+        B.createDeployAuthOutput({ address: address, sym: 'STABLE' })
+      ]
+      outs.forEach(function (o) {
+        o.satoshis.should.equal(1)
+        B.isBsv20(o.script).should.equal(true)
+      })
+    })
+
+    it('round-trips a full authority lifecycle', function () {
+      // deploy+auth -> auth output delegating mint rights -> mint by id -> burn.
+      var deploy = B.parseBsv20(B.buildDeployAuth({ address: address, sym: 'GOLD', dec: 8 }))
+      var auth = B.parseBsv20(B.buildAuth({ address: address, id: OUTPOINT }))
+      var mint = B.parseBsv20(B.buildMint({ address: address, id: OUTPOINT, amt: '1000' }))
+      var burn = B.parseBsv20(B.buildBurn({ address: address, id: OUTPOINT, amt: '400' }))
+      deploy.op.should.equal('deploy+auth')
+      auth.op.should.equal('auth')
+      mint.amt.should.equal('1000')
+      burn.amt.should.equal('400')
+      ;[deploy, auth, mint, burn].forEach(function (p) { p.p.should.equal('bsv-20') })
+    })
+  })
 })