@bsv/sdk 2.0.0-beta.0 → 2.0.1

package/src/script/__tests/Script.test.ts

@@ -354,12 +354,45 @@ describe('Script', () => {
   })
 
   describe('#findAndDelete', () => {
-    it('should find and delete this buffer', () => {
-      expect(
-        Script.fromASM('OP_RETURN f0f0')
-          .findAndDelete(Script.fromASM('f0f0'))
-          .toASM()
-      ).toEqual('OP_RETURN')
+    it('should delete all matching single-chunk scripts', () => {
+      const target = new Script().writeBin([0xf0, 0xf0])
+      const script = new Script()
+        .writeOpCode(OP.OP_RETURN)
+        .writeBin([0xf0, 0xf0])
+        .writeOpCode(OP.OP_1)
+        .writeBin([0xf0, 0xf0])
+
+      expect(script.findAndDelete(target).toASM()).toEqual('OP_RETURN OP_1')
+    })
+
+    it('should match OP_RETURN chunks with data', () => {
+      const target = new Script([{ op: OP.OP_RETURN, data: [0x01, 0x02, 0x03] }])
+      const script = new Script([
+        { op: OP.OP_RETURN, data: [0x01, 0x02, 0x03] },
+        { op: OP.OP_1 }
+      ])
+
+      expect(script.findAndDelete(target).toASM()).toEqual('OP_1')
+    })
+
+    it('should handle PUSHDATA2 payloads', () => {
+      const data = Array.from({ length: 300 }, (_, i) => i & 0xff)
+      const other = data.slice()
+      other[0] = (other[0] + 1) & 0xff
+
+      const target = new Script().writeBin(data)
+      const script = new Script().writeBin(other).writeBin(data).writeOpCode(OP.OP_1)
+
+      script.findAndDelete(target)
+      expect(script.chunks).toHaveLength(2)
+      expect(script.chunks[0].data).toEqual(other)
+      expect(script.chunks[1].op).toEqual(OP.OP_1)
+    })
+
+    it('should not delete when the target has multiple chunks', () => {
+      const script = Script.fromASM('OP_1')
+      const target = Script.fromASM('OP_1 OP_2')
+      expect(script.findAndDelete(target).toASM()).toEqual('OP_1')
     })
   })
 

package/src/script/__tests/Spend.test.ts

@@ -9,7 +9,7 @@ import LockingScript from '../../script/LockingScript'
 import UnlockingScript from '../../script/UnlockingScript'
 import MerklePath from '../../transaction/MerklePath'
 import ChainTracker from '../../transaction/ChainTracker'
-import spendValid from './spend.valid.vectors'
+import { preChronicle as spendValid } from './spend.valid.vectors'
 import Script from '../../script/Script'
 import BigNumber from '../../primitives/BigNumber'
 import ScriptChunk from '../../script/ScriptChunk'

package/src/script/__tests/SpendValildVectors.test.ts

@@ -0,0 +1,63 @@
+import PrivateKey from '../../primitives/PrivateKey'
+import { hash160, hash256 } from '../../primitives/Hash'
+import Curve from '../../primitives/Curve'
+import Spend from '../Spend'
+import P2PKH from '../templates/P2PKH'
+import RPuzzle from '../templates/RPuzzle'
+import Transaction from '../../transaction/Transaction'
+import LockingScript from '../LockingScript'
+import UnlockingScript from '../UnlockingScript'
+
+import { preChronicle as spendValid1, chronicle as spendValid2 } from './spend.valid.vectors'
+
+describe('Spend Valid Vectors 1', () => {
+  for (let i = 0; i < spendValid1.length; i++) {
+    const a = spendValid1[i]
+    if (a.length === 1) {
+      continue
+    }
+    it(`${i} ${a[2]}`, () => {
+      const spend = new Spend({
+        sourceTXID:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        sourceSatoshis: 1,
+        lockingScript: LockingScript.fromHex(a[1]),
+        transactionVersion: 1,
+        otherInputs: [],
+        outputs: [],
+        inputIndex: 0,
+        unlockingScript: UnlockingScript.fromHex(a[0]),
+        inputSequence: 0xffffffff,
+        lockTime: 0
+      })
+      expect(spend.validate()).toBe(true)
+    })
+  }
+})
+
+describe('Spend Valid Vectors 2', () => {
+  for (let i = 0; i < spendValid2.length; i++) {
+    const a = spendValid2[i]
+    if (a.length === 1) {
+      continue
+    }
+    it(`${i} ${a[2]}`, () => {
+      const spend = new Spend({
+        sourceTXID:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        sourceSatoshis: 1,
+        lockingScript: LockingScript.fromHex(a[1]),
+        transactionVersion: 1,
+        otherInputs: [],
+        outputs: [],
+        inputIndex: 0,
+        unlockingScript: UnlockingScript.fromHex(a[0]),
+        inputSequence: 0xffffffff,
+        lockTime: 0
+      })
+      expect(spend.validate()).toBe(true)
+    })
+  }
+})

package/src/script/__tests/lrshiftnum.test.ts

@@ -0,0 +1,185 @@
+import { toHex } from "../../primitives/utils"
+import Script from "../Script"
+import Spend from "../Spend"
+
+describe('lrshiftnum tests', () => {
+    jest.setTimeout(99999999)
+
+    test('0 valid OP_LSHIFTNUM Scripts', async () => {
+      for (const [script, stack] of lshiftnumValidScripts) {
+        const result = executeScriptCode(script, stack)
+        expect(result).toBe(true)
+      }
+    })
+
+    test('1 invalid OP_LSHIFTNUM Scripts', async () => {
+      for (const [script, stack] of lshiftnumInvalidScripts) {
+        try {
+          // An invalid script should throw...
+          const result = executeScriptCode(script, stack)
+          expect(true).toBe(false)
+        } catch (e) {
+          expect(e).toBeTruthy()
+        }
+      }
+    })
+
+    test('2 valid OP_RSHIFTNUM Scripts', async () => {
+      for (const [script, stack] of rshiftnumValidScripts) {
+        const result = executeScriptCode(script, stack)
+        expect(result).toBe(true)
+      }
+    })
+
+    test('3 invalid OP_RSHIFTNUM Scripts', async () => {
+      for (const [script, stack] of rshiftnumInvalidScripts) {
+        try {
+          // An invalid script should throw...
+          const result = executeScriptCode(script, stack)
+          expect(true).toBe(false)
+        } catch (e) {
+          expect(e).toBeTruthy()
+        }
+      }
+    })
+})
+
+const lshiftnumInvalidScripts: [string, string[]][] = [
+  ['OP_LSHIFTNUM',
+    ['']],
+  ['OP_1 OP_LSHIFTNUM',
+    ['']],
+  ['OP_2, OP_1NEGATE, OP_LSHIFTNUM',
+    ['']],
+]
+
+const lshiftnumValidScripts: [string, string[]][] = [
+  ['010203 OP_16 OP_LSHIFTNUM', // shift 2 bytes
+    ['0000010203']
+  ]
+  ,
+  ['OP_0 OP_1 OP_LSHIFTNUM',  // empty input data
+    ['']
+  ],
+  ['OP_1 OP_0 OP_LSHIFTNUM',  // shift by 0
+    ['01']
+  ],
+
+  ['OP_1 OP_8 OP_LSHIFTNUM',  // shift by size of stack element (or greater)
+    ['0001']
+  ],
+
+  ['0102 OP_8 OP_LSHIFTNUM', // shift 1 byte
+    ['000102']
+  ],
+
+  ['010203 OP_16 OP_LSHIFTNUM', // shift 2 bytes
+    ['0000010203']
+  ],
+
+  ['OP_1 OP_1 OP_LSHIFTNUM', // shift by 1 bit
+    ['02']
+  ],
+
+  ['OP_1 OP_2 OP_LSHIFTNUM', // shift by 2 bits
+    ['04']
+  ],
+
+  ['OP_1 OP_7 OP_LSHIFTNUM',
+    ['8000']
+  ],
+
+  ['0102 OP_9 OP_LSHIFTNUM', // shift by bits and bytes
+    ['000204']
+  ],
+
+  // Negative numbers
+  ['OP_1NEGATE OP_7 OP_LSHIFTNUM', // shift into the sign bit
+    ['8080']
+  ],
+
+  ['0180 OP_7 OP_LSHIFTNUM', // shift into the sign bit
+    ['8080']
+  ],
+]
+
+const rshiftnumInvalidScripts: [string, string[]][] = [
+  ['OP_RSHIFTNUM',
+    ['']],
+  ['OP_1 OP_RSHIFTNUM',
+    ['']],
+  ['OP_2 OP_1NEGATE OP_RSHIFTNUM',
+    ['']],
+]
+
+const rshiftnumValidScripts: [string, string[]][] = [
+  ['OP_0 OP_1 OP_RSHIFTNUM',  // empty input data
+    ['']],
+
+  ['OP_1 OP_0 OP_RSHIFTNUM',  // shift by 0
+    ['01']],
+
+  ['0102 OP_8 OP_RSHIFTNUM', // shift 1 byte
+    ['02']],
+
+  ['010203 OP_16 OP_RSHIFTNUM', // shift 2 bytes
+    ['03']],
+
+  ['OP_2 OP_1 OP_RSHIFTNUM', // shift by 1 bit
+    ['01']],
+
+  ['OP_4 OP_2 OP_RSHIFTNUM', // shift by 2 bits
+    ['01']],
+
+  ['0001 OP_1 OP_RSHIFTNUM', // 256 >> 1 -> 128
+    ['8000']],
+
+  ['0081 OP_1 OP_RSHIFTNUM', // -256 >> 1 -> -128
+    ['8080']],
+
+  ['010204 OP_9 OP_RSHIFTNUM', // shift by bits and bytes
+    ['0102']],
+
+  // round to 0
+  ['OP_1 OP_1 OP_RSHIFTNUM', // 1 >> 1 -> 0
+    ['']],
+
+  ['OP_1NEGATE OP_1 OP_RSHIFTNUM', // -1 >> 1 -> 0
+    ['']],
+]
+
+function executeScriptCode(script: Script | string, expectedStack: string[]): boolean {
+  if (typeof script === 'string')
+    script = Script.fromASM(script)
+  const spend = new Spend({
+    sourceTXID: '',
+    sourceOutputIndex: 0,
+    sourceSatoshis: 0,
+    lockingScript: script,
+    transactionVersion: 0,
+    otherInputs: [],
+    outputs: [],
+    unlockingScript: new Script(),
+    inputSequence: 0,
+    inputIndex: 0,
+    lockTime: 0,
+    memoryLimit: undefined,
+    isRelaxed: true
+  })
+  for (let i = 0; i < script.chunks.length; i++)
+    spend.step()
+  const stack = spend.stack
+  if (stack.length !== expectedStack.length) {
+    console.log(`script ${script.toASM()} expected stack length ${expectedStack.length} but got ${stack.length}`)
+    return false
+  }
+  for (let i = 0; i < expectedStack.length; i++) {
+    const expected = expectedStack[i]
+    const actual = toHex(stack[i])
+    if (expected !== actual) {
+      console.log(`script ${script.toASM()} expected stack[${i}] ${expected} but got ${actual}`)
+      return false
+    }
+  }
+  return true
+}