@smartledger/bsv 9.0.0 → 9.1.0

package/test/ordinals/bsv20.js

@@ -1,337 +0,0 @@
-'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 () {
-    // 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)
-  })
-
-  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')
-  })
-
-  // Code-review finding #4: leading-zero integer strings are canonicalized (indexers expect
-  // canonical decimals), while preserving arbitrary precision.
-  it('canonicalizes leading-zero amount strings', 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 = '18446744073709551615'
-    B.parseBsv20(B.buildMint({ address: address, tick: 'ORDI', amt: '0' + huge })).amt.should.equal(huge)
-  })
-
-  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/)
-    })
-  })
-
-  // 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') })
-    })
-  })
-})

package/test/ordinals/inscription.js

@@ -1,329 +0,0 @@
-'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')
-  })
-
-  // 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)
-    })
-  })
-
-  // Transferring a large inscription. The envelope is inert, so the spend is an
-  // ordinary P2PKH — but under pre-Genesis rules the interpreter could not even load
-  // the script, because total script size was capped at 10,000 bytes.
-  describe('transferring a large inscription', function () {
-    var I = bsv.Script.Interpreter
-    var Sighash = bsv.Transaction.Sighash
-    var BN = bsv.crypto.BN
-    var SIGHASH = bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID
-    // Pre-Genesis: no era bit, so the 520-byte element cap and the 10,000-byte script
-    // cap both still apply. Kept deliberately, to show what they reject.
-    var FLAGS = I.SCRIPT_VERIFY_STRICTENC | I.SCRIPT_ENABLE_SIGHASH_FORKID
-    // Current mainnet, where Genesis lifted both.
-    var MAINNET = I.mainnetFlags()
-    var saved
-
-    beforeEach(function () { saved = I.getLimits() })
-    afterEach(function () { I.setLimits(saved) })
-
-    // A signed transfer of a `kb`-sized inscription to a new owner.
-    function transfer (kb) {
-      var owner = bsv.PrivateKey.fromBuffer(Buffer.alloc(32, 11))
-      var recipient = bsv.PrivateKey.fromBuffer(Buffer.alloc(32, 22))
-      var lock = Ord.buildInscription({
-        address: owner.toAddress(),
-        contentType: 'image/png',
-        content: bsv.crypto.Random.getRandomBuffer(kb * 1024)
-      })
-      var spend = new bsv.Transaction()
-      spend.addInput(new bsv.Transaction.Input({
-        prevTxId: 'aa'.repeat(32), outputIndex: 0, script: bsv.Script.empty()
-      }), lock, 1)
-      spend.addOutput(new bsv.Transaction.Output({
-        script: bsv.Script.buildPublicKeyHashOut(recipient.toAddress()), satoshis: 1
-      }))
-      // Sign over the FULL previous locking script — envelope included. That is the
-      // script code the network uses; signing the base lock alone yields a signature
-      // that verifies against its own preimage and nothing else.
-      var sig = Sighash.sign(spend, owner, SIGHASH, 0, lock, new BN(1), FLAGS)
-      var unlock = new bsv.Script()
-        .add(Buffer.concat([sig.toDER(), Buffer.from([SIGHASH])]))
-        .add(owner.toPublicKey().toBuffer())
-      spend.inputs[0].setScript(unlock)
-      return { lock: lock, unlock: unlock, spend: spend, sig: sig, owner: owner }
-    }
-
-    // Both caps are derived from the ERA flags, not from the limit statics: see
-    // Interpreter#maxScriptElementSize and #maxScriptSize, each of which branches on
-    // isAfterGenesis(). Passing the era is therefore the whole fix — these tests used
-    // to call SmartContract.enableGenesis(), which raised process-wide statics instead
-    // and had to be undone in an afterEach or it changed the rules for every test that
-    // ran later.
-    function evaluate (t, flags) {
-      var interp = new I()
-      var ok = interp.verify(t.unlock, t.lock, t.spend, 0,
-        flags === undefined ? MAINNET : flags, new BN(1))
-      return { ok: ok, err: interp.errstr }
-    }
-
-    it('cannot be evaluated under pre-Genesis limits — two separate caps bite', function () {
-      // Explicitly pre-Genesis: FLAGS carries no era bit, so both caps still apply.
-      // Under 10 KB the script loads and the 520-byte push cap rejects the content...
-      var small = evaluate(transfer(3), FLAGS)
-      small.ok.should.equal(false)
-      small.err.should.equal('SCRIPT_ERR_PUSH_SIZE')
-      // ...over 10 KB it never gets that far: evaluate() refuses the script outright.
-      var big = evaluate(transfer(50), FLAGS)
-      big.ok.should.equal(false)
-      big.err.should.equal('SCRIPT_ERR_SCRIPT_SIZE')
-    })
-
-    it('evaluates under mainnet consensus, with the limit statics untouched', function () {
-      var before = JSON.stringify(I.getLimits())
-      var t = transfer(50)
-      t.lock.toBuffer().length.should.be.above(10000) // past the pre-Genesis cap
-      evaluate(t).ok.should.equal(true)
-      // The point of the change: no process-wide mutation was needed to get here.
-      JSON.stringify(I.getLimits()).should.equal(before)
-    })
-
-    it('agrees with a direct signature check against the sighash', function () {
-      // The fallback used when the interpreter cannot run: verify the signature over
-      // the sighash directly. It must agree with the interpreter where both work.
-      var t = transfer(50)
-      var hash = Sighash.sighash(t.spend, SIGHASH, 0, t.lock, new BN(1), FLAGS)
-      var sigOk = bsv.crypto.ECDSA.verify(hash, t.sig, t.owner.toPublicKey(), 'little')
-      sigOk.should.equal(true)
-      evaluate(t).ok.should.equal(true)
-    })
-
-    it('rejects a signature made over the base lock instead of the full script', function () {
-      var t = transfer(50)
-      var baseLock = bsv.Script.buildPublicKeyHashOut(t.owner.toAddress())
-      var wrong = Sighash.sign(t.spend, t.owner, SIGHASH, 0, baseLock, new BN(1), FLAGS)
-      var hash = Sighash.sighash(t.spend, SIGHASH, 0, t.lock, new BN(1), FLAGS)
-      // Verifies against its own (wrong) preimage, but not the one the network checks.
-      bsv.crypto.ECDSA.verify(hash, wrong, t.owner.toPublicKey(), 'little').should.equal(false)
-      t.spend.inputs[0].setScript(new bsv.Script()
-        .add(Buffer.concat([wrong.toDER(), Buffer.from([SIGHASH])]))
-        .add(t.owner.toPublicKey().toBuffer()))
-      var interp = new I()
-      interp.verify(t.spend.inputs[0].script, t.lock, t.spend, 0, FLAGS, new BN(1)).should.equal(false)
-    })
-  })
-})