@smartledger/bsv 7.4.0 → 7.5.1

package/test/gdaf/anchor_no_key_leak.js

@@ -0,0 +1,88 @@
+'use strict'
+
+/* global describe, it */
+
+// The GDAF anchoring wrappers take (payload, privateKey, options) while the underlying
+// SmartLedgerAnchor methods take (payload, metadata, utxos). Every wrapper forwarded
+// `privateKey` into a slot that is not a key. For anchorCredential/anchorBatch it landed
+// in `metadata`, which is JSON.stringify-ed straight into the OP_RETURN — so the secret
+// scalar was broadcast, and the key was recoverable from chain data with an identical WIF.
+
+require('chai').should()
+var bsv = require('../..')
+
+describe('GDAF anchoring never publishes key material', function () {
+  var key = bsv.PrivateKey.fromBuffer(Buffer.alloc(32, 7))
+  var utxos = [{
+    txId: '11'.repeat(32),
+    outputIndex: 0,
+    script: bsv.Script.buildPublicKeyHashOut(key.toAddress()).toHex(),
+    satoshis: 100000
+  }]
+  var HASH = 'ab'.repeat(32)
+
+  function gdaf () { return new bsv.GDAF() }
+
+  // Pull every OP_RETURN payload out of a built transaction, as UTF-8.
+  function payloadsOf (result) {
+    var tx = new bsv.Transaction((result.transaction || result.tx || result).toString())
+    return tx.outputs.map(function (o) {
+      var asm = o.script.toASM().split(' ')
+      return Buffer.from(asm[asm.length - 1], 'hex').toString('utf8')
+    })
+  }
+
+  function assertNoSecret (result) {
+    var scalarHex = key.bn.toString('hex')
+    var raw = (result.transaction || result.tx || result).toString()
+    raw.indexOf(Buffer.from(scalarHex, 'utf8').toString('hex')).should.equal(-1)
+    raw.indexOf(Buffer.from('"bn"', 'utf8').toString('hex')).should.equal(-1)
+    payloadsOf(result).forEach(function (p) {
+      p.indexOf(scalarHex).should.equal(-1)
+      p.indexOf('"bn"').should.equal(-1)
+    })
+  }
+
+  it('anchorCredential does not put the key in the OP_RETURN', function () {
+    return gdaf().anchorCredential(HASH, key, utxos).then(assertNoSecret)
+  })
+
+  it('anchorBatch does not put the key in the OP_RETURN', function () {
+    return gdaf().anchorBatch([HASH, 'cd'.repeat(32)], key, utxos).then(assertNoSecret)
+  })
+
+  it('accepts the documented { utxos, metadata } options shape', function () {
+    return gdaf().anchorCredential(HASH, key, { utxos: utxos, metadata: { issuer: 'did:web:example' } })
+      .then(function (r) {
+        assertNoSecret(r)
+        // The caller's own metadata still reaches the chain.
+        payloadsOf(r).join('').indexOf('did:web:example').should.not.equal(-1)
+      })
+  })
+
+  it('still accepts a bare UTXO array, the only shape that used to work', function () {
+    return gdaf().anchorCredential(HASH, key, utxos).then(function (r) {
+      r.should.be.an('object')
+    })
+  })
+
+  // Defence in depth: even reaching the payload builder with key material must fail
+  // loudly rather than broadcast it.
+  it('refuses to anchor metadata containing a PrivateKey instance', function () {
+    return gdaf().anchorCredential(HASH, key, { utxos: utxos, metadata: { signer: key } })
+      .then(function () { throw new Error('should not have anchored') },
+        function (err) { err.message.should.match(/Refusing to anchor/) })
+  })
+
+  it('refuses to anchor metadata carrying a key-shaped field', function () {
+    return gdaf().anchorCredential(HASH, key, { utxos: utxos, metadata: { wif: key.toWIF() } })
+      .then(function () { throw new Error('should not have anchored') },
+        function (err) { err.message.should.match(/looks like key material/) })
+  })
+
+  it('leaves ordinary metadata alone', function () {
+    return gdaf().anchorCredential(HASH, key, {
+      utxos: utxos, metadata: { id: 'urn:uuid:1', nested: { note: 'fine' } }
+    }).then(function (r) { assertNoSecret(r) })
+  })
+})

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/privatekey.js

@@ -205,7 +205,13 @@ describe('PrivateKey', function () {
         network: 'livenet'
       })
       var key = PrivateKey.fromObject(JSON.parse(json))
-      JSON.stringify(key).should.equal(json)
+      // toObject() is the deliberate export and still round-trips exactly...
+      JSON.stringify(key.toObject()).should.equal(json)
+      // ...but JSON.stringify() must NOT emit the secret. This test used to assert that
+      // it did, which is how a private key reached an OP_RETURN via the GDAF anchor path:
+      // anything that stringified an object holding a key published the scalar.
+      JSON.parse(JSON.stringify(key)).bn.should.equal('[REDACTED]')
+      JSON.stringify(key).indexOf('96c13222').should.equal(-1)
     })
 
     it('should input/output json', function () {
@@ -215,7 +221,13 @@ describe('PrivateKey', function () {
         network: 'livenet'
       })
       var key = PrivateKey.fromJSON(JSON.parse(json))
-      JSON.stringify(key).should.equal(json)
+      // toObject() is the deliberate export and still round-trips exactly...
+      JSON.stringify(key.toObject()).should.equal(json)
+      // ...but JSON.stringify() must NOT emit the secret. This test used to assert that
+      // it did, which is how a private key reached an OP_RETURN via the GDAF anchor path:
+      // anything that stringified an object holding a key published the scalar.
+      JSON.parse(JSON.stringify(key)).bn.should.equal('[REDACTED]')
+      JSON.stringify(key).indexOf('96c13222').should.equal(-1)
     })
 
     it('input json should correctly initialize network field', function () {
@@ -427,4 +439,69 @@ describe('PrivateKey', function () {
     var privkey = new PrivateKey('92VYMmwFLXRwXn5688edGxYYgMFsc3fUXYhGp17WocQhU6zG1kd')
     privkey.publicKey.toAddress().toString().should.equal('moiAvLUw16qgrwhFGo1eDnXHC2wPMYiv7Y')
   })
+  // Reported from the field against 7.4.0 and reproduced here. Each of these returned a
+  // DIFFERENT key or address than the caller asked for, silently.
+  describe('argument handling that used to produce the wrong key', function () {
+    var HEX = '0000000000000000000000000000000000000000000000000000000000000001'
+
+    it('honours the network passed to fromString instead of discarding it', function () {
+      // Returned a livenet key — and therefore a MAINNET address — so funds sent to it
+      // landed on the wrong network.
+      var k = PrivateKey.fromString(HEX, 'testnet')
+      k.network.name.should.equal('testnet')
+      k.toAddress().toString().should.equal(new PrivateKey(HEX, 'testnet').toAddress().toString())
+    })
+
+    it('agrees with the constructor for WIF input', function () {
+      var wif = new PrivateKey(HEX, 'testnet').toWIF()
+      PrivateKey.fromString(wif).toWIF().should.equal(wif)
+      PrivateKey.fromString(wif, 'testnet').toWIF().should.equal(wif)
+    })
+
+    it('rejects a network that contradicts the WIF rather than ignoring it', function () {
+      var wif = new PrivateKey(HEX, 'testnet').toWIF()
+      ;(function () { PrivateKey.fromString(wif, 'livenet') }).should.throw()
+    })
+
+    it('fromHex and the constructor return the SAME key', function () {
+      // These disagreed on the compression flag, so the same input produced two different
+      // addresses and two different WIFs. Restore by the wrong route, derive an address
+      // you never funded.
+      var a = new PrivateKey(HEX)
+      var b = PrivateKey.fromHex(HEX)
+      var c = PrivateKey.fromBuffer(Buffer.from(HEX, 'hex'))
+      b.compressed.should.equal(a.compressed)
+      b.toWIF().should.equal(a.toWIF())
+      b.toAddress().toString().should.equal(a.toAddress().toString())
+      c.toWIF().should.equal(a.toWIF())
+    })
+
+    it('still allows the legacy uncompressed form explicitly', function () {
+      PrivateKey.fromHex(HEX, null, false).compressed.should.equal(false)
+      PrivateKey.fromBuffer(Buffer.from(HEX, 'hex'), null, false).compressed.should.equal(false)
+    })
+  })
+
+  // JSON.stringify() on a key — or on any object holding one — used to emit the secret
+  // scalar. That is how a private key reached an OP_RETURN through the GDAF anchor path.
+  describe('does not leak the secret through JSON', function () {
+    it('redacts bn from JSON.stringify', function () {
+      var k = new PrivateKey()
+      var scalar = k.bn.toString('hex')
+      JSON.stringify(k).indexOf(scalar).should.equal(-1)
+      JSON.parse(JSON.stringify(k)).bn.should.equal('[REDACTED]')
+    })
+
+    it('redacts it when the key is nested inside another object', function () {
+      var k = new PrivateKey()
+      var payload = JSON.stringify({ context: { signer: k } })
+      payload.indexOf(k.bn.toString('hex')).should.equal(-1)
+    })
+
+    it('keeps toObject() exact, so deliberate export still round-trips', function () {
+      var k = new PrivateKey()
+      k.toObject().bn.should.equal(k.bn.toString('hex'))
+      PrivateKey.fromObject(k.toObject()).toWIF().should.equal(k.toWIF())
+    })
+  })
 })

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.4.0'
+module.exports = '7.5.1'