@smartledger/bsv 7.3.0 → 7.5.0

package/test/ordinals/bsv20.js

@@ -216,7 +216,122 @@ describe('Ordinals BSV-20 fungible tokens', function () {
         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

@@ -222,4 +222,98 @@ describe('Ordinals inscriptions', function () {
       }).satoshis.should.equal(1)
     })
   })
+
+  // The case that motivated making the script-size cap configurable: transferring a
+  // large inscription. The envelope is inert, so the spend is an ordinary P2PKH — but
+  // the interpreter could not even load the script, because total script size was a
+  // hard-coded 10,000 bytes that useGenesisLimits() did not lift.
+  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
+    var FLAGS = I.SCRIPT_VERIFY_STRICTENC | I.SCRIPT_ENABLE_SIGHASH_FORKID
+    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 }
+    }
+
+    function evaluate (t) {
+      var interp = new I()
+      var ok = interp.verify(t.unlock, t.lock, t.spend, 0, FLAGS, new BN(1))
+      return { ok: ok, err: interp.errstr }
+    }
+
+    it('cannot be evaluated under pre-Genesis limits — two separate caps bite', function () {
+      // Under 10 KB the script loads and the 520-byte push cap rejects the content...
+      var small = evaluate(transfer(3))
+      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.
+      // This is the cap useGenesisLimits() could not lift.
+      var big = evaluate(transfer(50))
+      big.ok.should.equal(false)
+      big.err.should.equal('SCRIPT_ERR_SCRIPT_SIZE')
+    })
+
+    it('evaluates once Genesis limits are enabled', function () {
+      bsv.SmartContract.enableGenesis()
+      var t = transfer(50)
+      t.lock.toBuffer().length.should.be.above(10000) // past the old hard-coded cap
+      evaluate(t).ok.should.equal(true)
+    })
+
+    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.
+      bsv.SmartContract.enableGenesis()
+      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 () {
+      bsv.SmartContract.enableGenesis()
+      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)
+    })
+  })
 })

package/test/ordinals/ordlock.js

@@ -28,13 +28,11 @@ describe('Ordinals OrdLock marketplace', function () {
   var saved
 
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   var seller = PrivateKey.fromRandom()
@@ -173,13 +171,11 @@ describe('Ordinals OrdLock — multi-output payments (royalties + marketplace fe
   var I = bsv.Script.Interpreter
   var saved
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   var seller = PrivateKey.fromRandom()
@@ -290,13 +286,11 @@ describe('Ordinals OrdLock — buildPurchaseTx (end-to-end)', function () {
   var I = bsv.Script.Interpreter
   var saved
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   var seller = PrivateKey.fromRandom()
@@ -386,13 +380,11 @@ describe('Ordinals OrdLock — full lifecycle (list -> buy / cancel)', function
   var I = bsv.Script.Interpreter
   var saved
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   var owner = PrivateKey.fromRandom() // current ordinal owner / seller
@@ -486,13 +478,11 @@ describe('Ordinals OrdLock — code-review regressions', function () {
   var I = bsv.Script.Interpreter
   var saved
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   var owner = PrivateKey.fromRandom()

package/test/script/genesis_limits.js

@@ -15,16 +15,10 @@ describe('Interpreter post-Genesis limits', function () {
   var saved
 
   beforeEach(function () {
-    saved = {
-      el: Interpreter.MAX_SCRIPT_ELEMENT_SIZE,
-      num: Interpreter.MAXIMUM_ELEMENT_SIZE,
-      ops: Interpreter.MAX_OPS_PER_SCRIPT
-    }
+    saved = Interpreter.getLimits()
   })
   afterEach(function () {
-    Interpreter.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    Interpreter.MAXIMUM_ELEMENT_SIZE = saved.num
-    Interpreter.MAX_OPS_PER_SCRIPT = saved.ops
+    Interpreter.setLimits(saved)
   })
 
   it('keeps pre-Genesis defaults out of the box', function () {
@@ -77,4 +71,46 @@ describe('Interpreter post-Genesis limits', function () {
     Interpreter.useGenesisLimits()
     run(manyOps).should.equal(true)
   })
+  // Total script size was a hard-coded 10,000 in evaluate(), so useGenesisLimits()
+  // could not lift it: any script over 10 KB failed SCRIPT_ERR_SCRIPT_SIZE regardless
+  // of what the caller asked for. That put every sizeable 1Sat Ordinals inscription
+  // out of reach of the interpreter entirely.
+  function scriptOfSize (bytes) {
+    // OP_DROP a single large push, then OP_1 — trivially true, but big.
+    return new Script()
+      .add(Buffer.alloc(bytes))
+      .add(Opcode.OP_DROP)
+      .add(Opcode.OP_1)
+  }
+
+  it('exposes the total script size cap as a constant, defaulting to pre-Genesis', function () {
+    Interpreter.MAX_SCRIPT_SIZE.should.equal(10000)
+  })
+
+  it('rejects a >10 KB script under default limits', function () {
+    Interpreter.useGenesisLimits() // lift element/ops caps so SIZE is what is under test
+    Interpreter.MAX_SCRIPT_SIZE = 10000 // ...but keep the pre-Genesis size cap
+    var interp = new Interpreter()
+    interp.verify(new Script(), scriptOfSize(20 * 1024)).should.equal(false)
+    interp.errstr.should.equal('SCRIPT_ERR_SCRIPT_SIZE')
+  })
+
+  it('allows a >10 KB script after useGenesisLimits()', function () {
+    Interpreter.useGenesisLimits()
+    run(scriptOfSize(20 * 1024)).should.equal(true)
+  })
+
+  it('useGenesisLimits raises all four caps, and getLimits/setLimits round-trip', function () {
+    var before = Interpreter.getLimits()
+    before.maxScriptSize.should.equal(10000)
+    Interpreter.useGenesisLimits(64 * 1024)
+    var after = Interpreter.getLimits()
+    after.maxScriptElementSize.should.equal(64 * 1024)
+    after.maximumElementSize.should.equal(64 * 1024)
+    after.maxOpsPerScript.should.equal(64 * 1024)
+    after.maxScriptSize.should.equal(64 * 1024)
+    Interpreter.setLimits(before)
+    Interpreter.getLimits().maxScriptSize.should.equal(10000)
+    Interpreter.MAX_SCRIPT_ELEMENT_SIZE.should.equal(520)
+  })
 })

package/test/smart_contract/covenants.js

@@ -24,13 +24,11 @@ describe('SmartContract covenants (v4.2.0)', function () {
   var saved
 
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis() // OP_PUSH_TX covenants need post-Genesis limits
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   var alice = PrivateKey.fromRandom()

package/test/smart_contract/dsl_debugger.js

@@ -17,13 +17,11 @@ describe('SmartContract covenant DSL + debugger (v4.5.0)', function () {
   var I = bsv.Script.Interpreter
   var saved
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   var alice = PrivateKey.fromRandom()

package/test/smart_contract/ordinal_transfer.js

@@ -29,13 +29,11 @@ describe('Ordinal-safe transfer (1-sat, SIGHASH_ALL)', function () {
   var bob = PrivateKey.fromRandom()
 
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   it('transferOrdinal recreates the 1-sat token among funding outputs and verifies', function () {

package/test/smart_contract/sighash_marketplace.js

@@ -32,13 +32,11 @@ describe('Configurable SIGHASH — SINGLE|ANYONECANPAY marketplace covenant', fu
   var flag = P.SIGHASH_SINGLE_ANYONECANPAY_FORKID // 0xc3
 
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   // Lock: authenticate the pushed preimage under `flag`, assert the flag, succeed.

package/test/smart_contract/token_generalized.js

@@ -24,13 +24,11 @@ describe('SmartContract generalized token (pluggable auth + multi-output)', func
   var saved
 
   before(function () {
-    saved = { el: I.MAX_SCRIPT_ELEMENT_SIZE, num: I.MAXIMUM_ELEMENT_SIZE, ops: I.MAX_OPS_PER_SCRIPT }
+    saved = I.getLimits()
     SC.enableGenesis()
   })
   after(function () {
-    I.MAX_SCRIPT_ELEMENT_SIZE = saved.el
-    I.MAXIMUM_ELEMENT_SIZE = saved.num
-    I.MAX_OPS_PER_SCRIPT = saved.ops
+    I.setLimits(saved)
   })
 
   function spendOf (lock, sats, outputs) {

package/version.js

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