@bsv/sdk 2.0.0-beta.0 → 2.0.1

package/src/transaction/__tests/Transaction.test.ts

@@ -1,7 +1,7 @@
 
 import BigNumber from '../../primitives/BigNumber'
 import TransactionSignature from '../../primitives/TransactionSignature'
-import { toHex, toArray, Writer } from '../../primitives/utils'
+import { toHex, toArray, Writer, Reader } from '../../primitives/utils'
 import Script from '../../script/Script'
 import UnlockingScript from '../../script/UnlockingScript'
 import LockingScript from '../../script/LockingScript'
@@ -20,6 +20,9 @@ import invalidTransactions from './tx.invalid.vectors'
 import validTransactions from './tx.valid.vectors'
 import bigTX from './bigtx.vectors'
 import { BroadcastResponse } from '../../transaction/Broadcaster'
+import { WalletInterface, CreateActionArgs, CreateActionResult } from '../../wallet/Wallet.interfaces'
+import ScriptChunk from '../../script/ScriptChunk'
+import OP from '../../script/OP'
 
 const BRC62Hex =
   '0100beef01fe636d0c0007021400fe507c0c7aa754cef1f7889d5fd395cf1f785dd7de98eed895dbedfe4e5bc70d1502ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e010b00bc4ff395efd11719b277694cface5aa50d085a0bb81f613f70313acd28cf4557010400574b2d9142b8d28b61d88e3b2c3f44d858411356b49a28a4643b6d1a6a092a5201030051a05fc84d531b5d250c23f4f886f6812f9fe3f402d61607f977b4ecd2701c19010000fd781529d58fc2523cf396a7f25440b409857e7e221766c57214b1d38c7b481f01010062f542f45ea3660f86c013ced80534cb5fd4c19d66c56e7e8c5d4bf2d40acc5e010100b121e91836fd7cd5102b654e9f72f3cf6fdbfd0b161c53a9c54b12c841126331020100000001cd4e4cac3c7b56920d1e7655e7e260d31f29d9a388d04910f1bbd72304a79029010000006b483045022100e75279a205a547c445719420aa3138bf14743e3f42618e5f86a19bde14bb95f7022064777d34776b05d816daf1699493fcdf2ef5a5ab1ad710d9c97bfb5b8f7cef3641210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013e660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000001000100000001ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e000000006a47304402203a61a2e931612b4bda08d541cfb980885173b8dcf64a3471238ae7abcd368d6402204cbf24f04b9aa2256d8901f0ed97866603d2be8324c2bfb7a37bf8fc90edd5b441210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013c660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000000'
@@ -904,6 +907,83 @@ describe('Transaction', () => {
       })
     })
 
+    function scriptFromLegacyData(bin: number[]): Script {
+      bin = [...bin]
+      const chunks: ScriptChunk[] = []
+
+      let inConditionalBlock: number = 0
+
+      const br = new Reader(bin)
+      while (!br.eof()) {
+        const op = br.readUInt8()
+
+        // if OP_RETURN and not in a conditional block, do not parse the rest of the data,
+        // rather just return the last chunk as data without prefixing with data length.
+        if (op === OP.OP_RETURN && inConditionalBlock === 0) {
+          chunks.push({
+            op,
+            data: br.read()
+          })
+          break
+        }
+
+        if (op === OP.OP_IF || op === OP.OP_NOTIF || op === OP.OP_VERIF || op === OP.OP_VERNOTIF) {
+          inConditionalBlock++
+        } else if (op === OP.OP_ENDIF) {
+          inConditionalBlock--
+        }
+
+        let len = 0
+        // eslint-disable-next-line @typescript-eslint/no-shadow
+        let data: number[] = []
+        if (op > 0 && op < OP.OP_PUSHDATA1) {
+          len = op
+          chunks.push({
+            data: br.read(len),
+            op
+          })
+        } else if (op === OP.OP_PUSHDATA1) {
+          try {
+            len = br.readUInt8()
+            data = br.read(len)
+          } catch {
+            br.read()
+          }
+          chunks.push({
+            data,
+            op
+          })
+        } else if (op === OP.OP_PUSHDATA2) {
+          try {
+            len = br.readUInt16LE()
+            data = br.read(len)
+          } catch {
+            br.read()
+          }
+          chunks.push({
+            data,
+            op
+          })
+        } else if (op === OP.OP_PUSHDATA4) {
+          try {
+            len = br.readUInt32LE()
+            data = br.read(len)
+          } catch {
+            br.read()
+          }
+          chunks.push({
+            data,
+            op
+          })
+        } else {
+          chunks.push({
+            op
+          })
+        }
+      }
+      return new Script(chunks)
+    }
+
     describe('vectors: sighash and serialization', () => {
       sighashVectors.forEach((vector, i) => {
         if (i === 0) {
@@ -912,7 +992,7 @@ describe('Transaction', () => {
         it(`should pass bitcoin-abc sighash test vector ${i}`, () => {
           const txbuf = toArray(vector[0], 'hex')
           const scriptbuf = toArray(vector[1], 'hex')
-          const subScript = Script.fromBinary(scriptbuf)
+          const subScript = scriptFromLegacyData(scriptbuf)
           const nIn = vector[2] as number
           const nHashType = vector[3] as number
           const sighashBuf = toArray(vector[4], 'hex')
@@ -936,7 +1016,8 @@ describe('Transaction', () => {
             subscript: subScript,
             inputSequence: input.sequence ?? 0xffffffff,
             lockTime: tx.lockTime,
-            scope: nHashType
+            scope: nHashType,
+            ignoreChronicle: true
           })
           const hash = hash256(preimage)
           hash.reverse()
@@ -1379,6 +1460,563 @@ describe('Transaction', () => {
     })
   })
 
+  describe('completeWithWallet', () => {
+    // Mock implementation of WalletInterface for testing
+    class MockWallet implements Partial<WalletInterface> {
+      public lastCreateActionArgs: CreateActionArgs | null = null
+      public lastSignActionArgs: any = null
+      public signActionCalled: boolean = false
+
+      async createAction(args: CreateActionArgs, originator?: string): Promise<CreateActionResult> {
+        // Store the args for verification
+        this.lastCreateActionArgs = args
+
+        // Create a simple transaction from the action args
+        const tx = new Transaction(args.version || 1)
+
+        // Add inputs if provided
+        if (args.inputs) {
+          for (const input of args.inputs) {
+            // Parse outpoint string format "txid.vout"
+            const [txid, voutStr] = input.outpoint.split('.')
+
+            // Check if this is using the signAction flow (has unlockingScriptLength)
+            const hasTemplate = input.unlockingScriptLength != null
+
+            // For signAction flow, we need placeholder scripts to serialize the transaction
+            // These will be replaced by the actual scripts in signAction
+            const unlockingScript = hasTemplate
+              ? Script.fromASM('OP_0') // Placeholder for template inputs
+              : (input.unlockingScript ? Script.fromHex(input.unlockingScript) : Script.fromASM('OP_1'))
+
+            tx.addInput({
+              sourceTXID: txid,
+              sourceOutputIndex: parseInt(voutStr),
+              unlockingScript
+            })
+          }
+        }
+
+        // Add outputs if provided
+        if (args.outputs) {
+          for (const output of args.outputs) {
+            tx.addOutput({
+              satoshis: output.satoshis,
+              lockingScript: Script.fromHex(output.lockingScript)
+            })
+          }
+        }
+
+        // Check if this should return signableTransaction
+        if (args.options?.signAndProcess === false) {
+          return {
+            signableTransaction: {
+              tx: tx.toBEEF(),
+              reference: 'test-reference-123'
+            }
+          }
+        }
+
+        // Return the transaction as Atomic BEEF in CreateActionResult format
+        return {
+          tx: tx.toAtomicBEEF(),
+          txid: tx.id('hex')
+        }
+      }
+
+      async signAction(args: any, originator?: string): Promise<CreateActionResult> {
+        this.signActionCalled = true
+        this.lastSignActionArgs = args
+
+        // Get the reference to find the original transaction
+        // For testing, we'll create a new transaction with the provided unlocking scripts
+        const tx = new Transaction(1)
+
+        // Add inputs with the provided unlocking scripts from spends
+        for (const [index, spend] of Object.entries(args.spends)) {
+          tx.addInput({
+            sourceTXID: '00'.repeat(32),
+            sourceOutputIndex: parseInt(index),
+            unlockingScript: Script.fromHex((spend as any).unlockingScript)
+          })
+        }
+
+        // Return atomic BEEF
+        return {
+          tx: tx.toAtomicBEEF(),
+          txid: tx.id('hex')
+        }
+      }
+    }
+
+    it('should properly complete a transaction using a wallet', async () => {
+      // Create a private key and address for testing
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+
+      // Create a source transaction with a merkle path
+      const sourceTx = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 10000
+        }],
+        0
+      )
+
+      // Assign a merkle path to simulate a confirmed transaction
+      const sourceTxID = sourceTx.id('hex')
+      sourceTx.merklePath = new MerklePath(1000, [
+        [
+          { offset: 0, hash: sourceTxID, txid: true },
+          { offset: 1, duplicate: true }
+        ]
+      ])
+
+      // Create another source transaction without merkle path
+      const sourceTx2 = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 5000
+        }],
+        0
+      )
+
+      // Create unlocking scripts for the inputs
+      const unlockingScript1 = Script.fromASM('OP_0 OP_0') // Placeholder unlocking script
+      const unlockingScript2 = Script.fromASM('OP_0 OP_0') // Placeholder unlocking script
+
+      // Create the transaction to complete
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceTransaction: sourceTx,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff,
+            unlockingScript: unlockingScript1
+          },
+          {
+            sourceTransaction: sourceTx2,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff,
+            unlockingScript: unlockingScript2
+          }
+        ],
+        [{
+          satoshis: 14000,
+          lockingScript: p2pkh.lock(publicKeyHash)
+        }],
+        0
+      )
+
+      // Add metadata with labels
+      tx.updateMetadata({
+        labels: ['test-label-1', 'test-label-2']
+      })
+
+      // Create a mock wallet
+      const mockWallet = new MockWallet()
+
+      // Complete the transaction with the wallet
+      await tx.completeWithWallet(mockWallet, 'Test transaction completion')
+
+      // Verify that the wallet's createAction was called with correct arguments
+      expect(mockWallet.lastCreateActionArgs).not.toBeNull()
+      expect(mockWallet.lastCreateActionArgs!.description).toBe('Test transaction completion')
+      expect(mockWallet.lastCreateActionArgs!.inputs).toHaveLength(2)
+      expect(mockWallet.lastCreateActionArgs!.outputs).toHaveLength(1)
+      expect(mockWallet.lastCreateActionArgs!.labels).toEqual(['test-label-1', 'test-label-2'])
+
+      // Verify that the transaction structure was updated
+      expect(tx.inputs).toHaveLength(2)
+      expect(tx.outputs).toHaveLength(1)
+
+      // Verify that original metadata labels are preserved
+      expect(tx.metadata).toHaveProperty('labels')
+      expect(tx.metadata.labels).toContain('test-label-1')
+      expect(tx.metadata.labels).toContain('test-label-2')
+    })
+
+    it('should throw an error when inputs do not have source transactions', async () => {
+      // Create a transaction with only TXID references (no source transactions)
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceTXID: '00'.repeat(32),
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff
+          }
+        ],
+        [{
+          satoshis: 5000,
+          lockingScript: Script.fromASM('OP_DUP OP_HASH160 OP_EQUALVERIFY OP_CHECKSIG')
+        }],
+        0
+      )
+
+      // Create a mock wallet
+      const mockWallet = new MockWallet()
+
+      // Expect completeWithWallet to throw an error
+      await expect(tx.completeWithWallet(mockWallet))
+        .rejects
+        .toThrow('All inputs must have a sourceTransaction when using completeWithWallet')
+    })
+
+    it('should throw an error when inputs do not have unlocking scripts', async () => {
+      // Create a private key and address for testing
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+
+      // Create a source transaction
+      const sourceTx = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 10000
+        }],
+        0
+      )
+
+      // Create a transaction with source transaction but no unlocking script
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceTransaction: sourceTx,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff
+            // Note: no unlockingScript property
+          }
+        ],
+        [{
+          satoshis: 5000,
+          lockingScript: Script.fromASM('OP_DUP OP_HASH160 OP_EQUALVERIFY OP_CHECKSIG')
+        }],
+        0
+      )
+
+      // Create a mock wallet
+      const mockWallet = new MockWallet()
+
+      // Expect completeWithWallet to throw an error
+      await expect(tx.completeWithWallet(mockWallet))
+        .rejects
+        .toThrow('All inputs must have an unlockingScript when using completeWithWallet')
+    })
+
+    it('should use signAction flow when inputs have unlockingScriptTemplate', async () => {
+      // Create a private key and address for testing
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+
+      // Create a source transaction
+      const sourceTx = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 10000
+        }],
+        0
+      )
+
+      // Create a mock unlocking script template
+      const mockTemplate = {
+        sign: async (tx: Transaction, inputIndex: number): Promise<UnlockingScript> => {
+          // Return a simple unlocking script
+          return Script.fromASM('OP_1 OP_2')
+        },
+        estimateLength: async (tx: Transaction, inputIndex: number): Promise<number> => {
+          return 73 // Standard P2PKH unlocking script length estimate
+        }
+      }
+
+      // Create a transaction with a template
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceTransaction: sourceTx,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff,
+            unlockingScriptTemplate: mockTemplate
+          }
+        ],
+        [{
+          satoshis: 9000,
+          lockingScript: p2pkh.lock(publicKeyHash)
+        }],
+        0
+      )
+
+      // Create a mock wallet
+      const mockWallet = new MockWallet()
+
+      // Complete the transaction with the wallet
+      await tx.completeWithWallet(mockWallet, 'Test with template')
+
+      // Verify that signAction was called
+      expect(mockWallet.signActionCalled).toBe(true)
+      expect(mockWallet.lastSignActionArgs).not.toBeNull()
+      expect(mockWallet.lastSignActionArgs.reference).toBe('test-reference-123')
+      expect(mockWallet.lastSignActionArgs.spends).toHaveProperty('0')
+      expect(mockWallet.lastSignActionArgs.spends[0].unlockingScript).toBe(Script.fromASM('OP_1 OP_2').toHex())
+
+      // Verify that createAction was called with signAndProcess: false
+      expect(mockWallet.lastCreateActionArgs).not.toBeNull()
+      expect(mockWallet.lastCreateActionArgs!.options?.signAndProcess).toBe(false)
+      expect(mockWallet.lastCreateActionArgs!.inputs).toHaveLength(1)
+      const firstInput = mockWallet.lastCreateActionArgs!.inputs![0]
+      expect(firstInput).toBeDefined()
+      expect(firstInput.unlockingScriptLength).toBe(73)
+    })
+
+    it('should handle mixed inputs with both templates and scripts', async () => {
+      // Create a private key and address for testing
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+
+      // Create source transactions
+      const sourceTx1 = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 10000
+        }],
+        0
+      )
+
+      const sourceTx2 = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 5000
+        }],
+        0
+      )
+
+      // Create a mock template
+      const mockTemplate = {
+        sign: async (tx: Transaction, inputIndex: number): Promise<UnlockingScript> => {
+          return Script.fromASM('OP_1 OP_2')
+        },
+        estimateLength: async (tx: Transaction, inputIndex: number): Promise<number> => {
+          return 73
+        }
+      }
+
+      // Create a transaction with mixed inputs
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceTransaction: sourceTx1,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff,
+            unlockingScriptTemplate: mockTemplate // First input uses template
+          },
+          {
+            sourceTransaction: sourceTx2,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff,
+            unlockingScript: Script.fromASM('OP_3 OP_4') // Second input has script already
+          }
+        ],
+        [{
+          satoshis: 14000,
+          lockingScript: p2pkh.lock(publicKeyHash)
+        }],
+        0
+      )
+
+      // Create a mock wallet
+      const mockWallet = new MockWallet()
+
+      // Complete the transaction with the wallet
+      await tx.completeWithWallet(mockWallet, 'Test with mixed inputs')
+
+      // Verify that signAction was called (because at least one template exists)
+      expect(mockWallet.signActionCalled).toBe(true)
+
+      // Verify spends includes both inputs
+      expect(mockWallet.lastSignActionArgs.spends).toHaveProperty('0')
+      expect(mockWallet.lastSignActionArgs.spends).toHaveProperty('1')
+
+      // First input should have template-generated script
+      expect(mockWallet.lastSignActionArgs.spends[0].unlockingScript).toBe(Script.fromASM('OP_1 OP_2').toHex())
+
+      // Second input should have pre-existing script
+      expect(mockWallet.lastSignActionArgs.spends[1].unlockingScript).toBe(Script.fromASM('OP_3 OP_4').toHex())
+
+      // Verify createAction args
+      const firstInputArg = mockWallet.lastCreateActionArgs!.inputs![0]
+      const secondInputArg = mockWallet.lastCreateActionArgs!.inputs![1]
+      expect(firstInputArg).toBeDefined()
+      expect(secondInputArg).toBeDefined()
+      expect(firstInputArg.unlockingScriptLength).toBe(73)
+      expect(secondInputArg.unlockingScript).toBe(Script.fromASM('OP_3 OP_4').toHex())
+    })
+
+    it('should throw error when template input has neither script nor template', async () => {
+      const privateKey = new PrivateKey(1)
+      const publicKey = new Curve().g.mul(privateKey)
+      const publicKeyHash = hash160(publicKey.encode(true)) as number[]
+      const p2pkh = new P2PKH()
+
+      const sourceTx1 = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 10000
+        }],
+        0
+      )
+
+      const sourceTx2 = new Transaction(
+        1,
+        [],
+        [{
+          lockingScript: p2pkh.lock(publicKeyHash),
+          satoshis: 5000
+        }],
+        0
+      )
+
+      // Mock template for first input
+      const mockTemplate = {
+        sign: async (tx: Transaction, inputIndex: number): Promise<UnlockingScript> => {
+          return Script.fromASM('OP_1 OP_2')
+        },
+        estimateLength: async (tx: Transaction, inputIndex: number): Promise<number> => {
+          return 73
+        }
+      }
+
+      // Create transaction where second input has neither script nor template
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceTransaction: sourceTx1,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff,
+            unlockingScriptTemplate: mockTemplate
+          },
+          {
+            sourceTransaction: sourceTx2,
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff
+            // No unlockingScript or unlockingScriptTemplate
+          }
+        ],
+        [{
+          satoshis: 14000,
+          lockingScript: p2pkh.lock(publicKeyHash)
+        }],
+        0
+      )
+
+      const mockWallet = new MockWallet()
+
+      // Should throw error about missing script/template on input 1
+      await expect(tx.completeWithWallet(mockWallet))
+        .rejects
+        .toThrow('Input 1 must have either an unlockingScript or unlockingScriptTemplate')
+    })
+
+    it('should pass options to createAction for standard flow', async () => {
+      // Create a simple transaction
+      const sourceTx = new Transaction(1, [], [{ lockingScript: testP2PKHScript, satoshis: 10000 }], 0)
+      const tx = new Transaction(
+        1,
+        [{
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff,
+          unlockingScript: Script.fromASM('OP_0 OP_0')
+        }],
+        [{ satoshis: 9000, lockingScript: testP2PKHScript }],
+        0
+      )
+
+      const mockWallet = new MockWallet()
+      const options = {
+        noSend: true,
+        acceptDelayedBroadcast: false,
+        returnTXIDOnly: true
+      }
+
+      await tx.completeWithWallet(mockWallet, 'Test with options', undefined, options)
+
+      // Verify options were passed to createAction
+      expect(mockWallet.lastCreateActionArgs?.options).toEqual(options)
+    })
+
+    it('should pass options to both createAction and signAction for template flow', async () => {
+      // Create transaction with template
+      const sourceTx = new Transaction(1, [], [{ lockingScript: testP2PKHScript, satoshis: 10000 }], 0)
+      const tx = new Transaction(
+        1,
+        [{
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff,
+          unlockingScriptTemplate: {
+            sign: async (tx, inputIndex) => Script.fromASM('OP_0 OP_0'),
+            estimateLength: async (tx, inputIndex) => 100
+          }
+        }],
+        [{ satoshis: 9000, lockingScript: testP2PKHScript }],
+        0
+      )
+
+      const mockWallet = new MockWallet()
+      const options = {
+        noSend: true,
+        acceptDelayedBroadcast: false,
+        returnTXIDOnly: true,
+        trustSelf: 'known' as any,
+        randomizeOutputs: false
+      }
+
+      await tx.completeWithWallet(mockWallet, 'Test template with options', undefined, options)
+
+      // Verify signAndProcess: false was set for createAction (required for template flow)
+      expect(mockWallet.lastCreateActionArgs?.options?.signAndProcess).toBe(false)
+
+      // Verify other options were passed to createAction
+      expect(mockWallet.lastCreateActionArgs?.options?.trustSelf).toBe('known')
+      expect(mockWallet.lastCreateActionArgs?.options?.randomizeOutputs).toBe(false)
+
+      // Verify signAction was called and received the applicable options
+      expect(mockWallet.signActionCalled).toBe(true)
+      expect(mockWallet.lastSignActionArgs?.options).toEqual({
+        acceptDelayedBroadcast: false,
+        returnTXIDOnly: true,
+        noSend: true,
+        sendWith: undefined
+      })
+    })
+  })
+
   describe('preventResourceExhaustionSmall', () => {
     it('should run script evaluation and pass so long as we stay within the limit', async () => {
       const sourceTransaction = new Transaction()