@bsv/wallet-toolbox 1.7.14 → 1.7.15

package/mobile/node_modules/@bsv/sdk/src/script/__tests/Spend.test.ts

@@ -0,0 +1,555 @@
+import PrivateKey from '../../primitives/PrivateKey'
+import { hash160, hash256 } from '../../primitives/Hash'
+import Curve from '../../primitives/Curve'
+import Spend from '../../script/Spend'
+import P2PKH from '../../script/templates/P2PKH'
+import RPuzzle from '../../script/templates/RPuzzle'
+import Transaction from '../../transaction/Transaction'
+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 Script from '../../script/Script'
+import BigNumber from '../../primitives/BigNumber'
+import ScriptChunk from '../../script/ScriptChunk'
+import OP from '../../script/OP'
+
+export class MockChain implements ChainTracker {
+  mock: { blockheaders: string[] }
+
+  constructor(mock: { blockheaders: string[] }) {
+    this.mock = mock
+  }
+
+  addBlock(merkleRoot: string) {
+    this.mock.blockheaders.push(merkleRoot)
+  }
+
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    return this.mock.blockheaders[height] === root
+  }
+
+  async currentHeight(): Promise<number> {
+    return this.mock.blockheaders.length
+  }
+}
+
+const ZERO_TXID = '0'.repeat(64)
+
+const cloneChunks = (chunks: ScriptChunk[]): ScriptChunk[] =>
+  chunks.map((chunk) => ({
+    op: chunk.op,
+    data: Array.isArray(chunk.data) ? chunk.data.slice() : undefined
+  }))
+
+const lockingScriptFromAsm = (asm: string): LockingScript => {
+  const parsed = Script.fromASM(asm)
+  return new LockingScript(cloneChunks(parsed.chunks))
+}
+
+const pushChunkFromBytes = (bytes: number[]): ScriptChunk => {
+  if (bytes.length === 0) {
+    return { op: OP.OP_0, data: [] }
+  }
+  if (bytes.length === 1) {
+    if (bytes[0] >= 1 && bytes[0] <= 16) {
+      return { op: OP.OP_1 + (bytes[0] - 1) }
+    }
+    if (bytes[0] === 0x81) {
+      return { op: OP.OP_1NEGATE }
+    }
+  }
+  let op: number
+  if (bytes.length < OP.OP_PUSHDATA1) op = bytes.length
+  else if (bytes.length < Math.pow(2, 8)) op = OP.OP_PUSHDATA1
+  else if (bytes.length < Math.pow(2, 16)) op = OP.OP_PUSHDATA2
+  else op = OP.OP_PUSHDATA4
+  return {
+    op,
+    data: bytes.slice()
+  }
+}
+
+const createUnlockingScriptFromPushes = (pushes: number[][]): UnlockingScript =>
+  new UnlockingScript(pushes.map(pushChunkFromBytes))
+
+const createSpendWithPushes = (lockingAsm: string, unlockingPushes: number[][]): Spend =>
+  new Spend({
+    sourceTXID: ZERO_TXID,
+    sourceOutputIndex: 0,
+    sourceSatoshis: 1,
+    lockingScript: lockingScriptFromAsm(lockingAsm),
+    transactionVersion: 1,
+    otherInputs: [],
+    outputs: [],
+    inputIndex: 0,
+    unlockingScript: createUnlockingScriptFromPushes(unlockingPushes),
+    inputSequence: 0xffffffff,
+    lockTime: 0
+  })
+
+const scriptNumBytes = (value: bigint): number[] => new BigNumber(value).toScriptNum()
+
+describe('Spend', () => {
+  it('Successfully validates a P2PKH spend', async () => {
+    const privateKey = new PrivateKey(1)
+    const publicKey = privateKey.toPublicKey()
+    const hash = publicKey.toHash()
+    const p2pkh = new P2PKH()
+    const lockingScript = p2pkh.lock(hash)
+    const satoshis = 1
+    const unlockingTemplate = p2pkh.unlock(privateKey)
+    const sourceTx = new Transaction(
+      1,
+      [],
+      [
+        {
+          lockingScript,
+          satoshis
+        }
+      ],
+      0
+    )
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff
+        }
+      ],
+      [],
+      0
+    )
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  })
+  it('Fails to verify a P2PKH spend with the wrong key', async () => {
+    const privateKey = new PrivateKey(1)
+    const publicKey = privateKey.toPublicKey()
+    const wrongPrivateKey = new PrivateKey(2)
+    const hash = publicKey.toHash()
+    const p2pkh = new P2PKH()
+    const lockingScript = p2pkh.lock(hash)
+    const satoshis = 1
+    const unlockingTemplate = p2pkh.unlock(wrongPrivateKey)
+    const sourceTx = new Transaction(
+      1,
+      [],
+      [
+        {
+          lockingScript,
+          satoshis
+        }
+      ],
+      0
+    )
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff
+        }
+      ],
+      [],
+      0
+    )
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    expect(() => spend.validate()).toThrow()
+  })
+  it('Successfully validates an R-puzzle spend', async () => {
+    const k = new PrivateKey(2)
+    const c = new Curve()
+    let r = c.g.mul(k).x?.umod(c.n)?.toArray()
+    if (r !== null && r !== undefined) {
+      r = r[0] > 127 ? [0, ...r] : r
+    }
+
+    const puz = new RPuzzle()
+    const lockingScript = puz.lock(r ?? [])
+    const satoshis = 1
+
+    // ✅ Fix: Ensure privateKey is valid and within range
+    const privateKey = PrivateKey.fromRandom()
+
+    const unlockingTemplate = puz.unlock(k, privateKey)
+    const sourceTx = new Transaction(
+      1,
+      [],
+      [
+        {
+          lockingScript,
+          satoshis
+        }
+      ],
+      0
+    )
+
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff
+        }
+      ],
+      [],
+      0
+    )
+
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  })
+
+  it('maintains endianness when shifting right', () => {
+    const spend = createSpendWithPushes(
+      'OP_1 OP_RSHIFT 0080 OP_EQUAL',
+      [[0x01, 0x00]]
+    )
+
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('maintains endianness when shifting left', () => {
+    const spend = createSpendWithPushes(
+      'OP_1 OP_LSHIFT 0100 OP_EQUAL',
+      [[0x00, 0x80]]
+    )
+
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('Successfully validates an R-puzzle spend (HASH256)', async () => {
+    const k = new PrivateKey(2)
+    const c = new Curve()
+    let r = c.g.mul(k).x?.umod(c.n)?.toArray()
+    if (r !== null && r !== undefined) {
+      r = r[0] > 127 ? [0, ...r] : r
+      r = hash256(r)
+    }
+    const puz = new RPuzzle('HASH256')
+    const lockingScript = puz.lock(r ?? [])
+    const satoshis = 1
+
+    // ✅ Fix: Ensure privateKey is valid and within range
+    const privateKey = PrivateKey.fromRandom()
+
+    const unlockingTemplate = puz.unlock(k, privateKey)
+    const sourceTx = new Transaction(
+      1,
+      [],
+      [
+        {
+          lockingScript,
+          satoshis
+        }
+      ],
+      0
+    )
+
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff
+        }
+      ],
+      [],
+      0
+    )
+
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  })
+
+  it('Fails to validate an R-puzzle spend with the wrong K value', async () => {
+    const k = new PrivateKey(2)
+    const wrongK = new PrivateKey(5)
+    const c = new Curve()
+    let r = c.g.mul(k).x?.umod(c.n)?.toArray()
+    if (r !== null && r !== undefined) {
+      r = r[0] > 127 ? [0, ...r] : r
+      r = hash256(r)
+    }
+    const puz = new RPuzzle('HASH256')
+    const lockingScript = puz.lock(r ?? [])
+    const satoshis = 1
+
+    // ✅ Fix: Ensure privateKey is valid and within range
+    const privateKey = PrivateKey.fromRandom()
+
+    const unlockingTemplate = puz.unlock(wrongK, privateKey)
+    const sourceTx = new Transaction(
+      1,
+      [],
+      [
+        {
+          lockingScript,
+          satoshis
+        }
+      ],
+      0
+    )
+
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff
+        }
+      ],
+      [],
+      0
+    )
+
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+
+    expect(() => spend.validate()).toThrow()
+  })
+
+  it('Fails to validate an R-puzzle spend with the wrong hash', async () => {
+    const k = new PrivateKey(2)
+    const c = new Curve()
+    let r = c.g.mul(k).x?.umod(c.n)?.toArray()
+    if (r !== null && r !== undefined) {
+      r = r[0] > 127 ? [0, ...r] : r
+      r = hash160(r)
+    }
+    const puz = new RPuzzle('HASH256')
+    const lockingScript = puz.lock(r ?? [])
+    const satoshis = 1
+
+    // ✅ Fix: Ensure privateKey is valid and within range
+    const privateKey = PrivateKey.fromRandom()
+
+    const unlockingTemplate = puz.unlock(k, privateKey)
+    const sourceTx = new Transaction(
+      1,
+      [],
+      [
+        {
+          lockingScript,
+          satoshis
+        }
+      ],
+      0
+    )
+
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          sourceTransaction: sourceTx,
+          sourceOutputIndex: 0,
+          sequence: 0xffffffff
+        }
+      ],
+      [],
+      0
+    )
+
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+
+    expect(() => spend.validate()).toThrow()
+  })
+  for (let i = 0; i < spendValid.length; i++) {
+    const a = spendValid[i]
+    if (a.length === 1) {
+      continue
+    }
+    it(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('bigint stack operand handling', () => {
+    it('OP_PICK rejects indexes that exceed the stack length without tripping JS safe-integer limits', () => {
+      const spend = createSpendWithPushes('OP_PICK', [
+        [0x01],
+        scriptNumBytes((1n << 60n) + 5n)
+      ])
+      expect(() => spend.validate()).toThrow('OP_PICK requires the top stack element to be 0 or a positive number less than the current size of the stack.')
+    })
+
+    it('OP_SPLIT surfaces its range error for very large positions', () => {
+      const spend = createSpendWithPushes('OP_SPLIT', [
+        [0x01, 0x02],
+        scriptNumBytes(1n << 60n)
+      ])
+      expect(() => spend.validate()).toThrow('OP_SPLIT requires the first stack item to be a non-negative number less than or equal to the size of the second-from-top stack item.')
+    })
+
+    it('OP_NUM2BIN enforces the max element size before reaching JS number limits', () => {
+      const spend = createSpendWithPushes('OP_NUM2BIN', [
+        [0x01],
+        scriptNumBytes(1n << 60n)
+      ])
+      expect(() => spend.validate()).toThrow("It's not currently possible to push data larger than 1073741824 bytes or negative size.")
+    })
+
+    it('OP_LSHIFT accepts shift counts larger than Number.MAX_SAFE_INTEGER when no shift work is required', () => {
+      const spend = createSpendWithPushes('OP_LSHIFT OP_DROP OP_TRUE', [
+        [],
+        scriptNumBytes(1n << 60n)
+      ])
+      expect(spend.validate()).toBe(true)
+    })
+  })
+
+  it('Successfully validates a spend where sequence is set to undefined', async () => {
+    const sourceTransaction = new Transaction(
+      1,
+      [{
+        sourceTXID: '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        unlockingScript: Script.fromASM('OP_TRUE'),
+        sequence: 0xffffffff
+      }],
+      [
+        {
+          lockingScript: Script.fromASM('OP_NOP'),
+          satoshis: 2
+        }
+      ],
+      0
+    )
+    const txid = sourceTransaction.id('hex')
+    sourceTransaction.merklePath = MerklePath.fromCoinbaseTxidAndHeight(txid, 0)
+    const chain = new MockChain({ blockheaders: [] })
+    chain.addBlock(txid)
+
+    const spendTx = new Transaction(
+      1,
+      [
+        {
+          unlockingScript: Script.fromASM('OP_TRUE'),
+          sourceTransaction,
+          sourceOutputIndex: 0
+        }
+      ],
+      [{
+          lockingScript: Script.fromASM('OP_NOP'),
+          satoshis: 1
+      }],
+      0
+    )
+
+    const valid = await spendTx.verify(chain)
+    
+    expect(valid).toBe(true)
+
+    const b = spendTx.toBinary()
+    const t = Transaction.fromBinary(b)
+    expect(t.inputs[0].sequence).toBe(0xffffffff)
+
+    const b2 = spendTx.toEF()
+    const t2 = Transaction.fromEF(b2)
+    expect(t2.inputs[0].sequence).toBe(0xffffffff)
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/script/__tests/SpendComplex.test.ts

@@ -0,0 +1,48 @@
+import Script from '../../script/Script'
+import Spend from '../../script/Spend'
+import Transaction from '../../transaction/Transaction'
+import { verifyNotNull } from '../../primitives/utils'
+
+describe('SpendComplex', () => {
+  it('complex unlock script validation', () => {
+    const rawTx =
+      '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'
+    const lockingScript =
+      '2097dfd76851bf465e8f715593b217714858bbe9570ff3bd5e33840a34e20ff0262102ba79df5f8ae7604a9830f03c7933028186aede0675a16f025dc4f8be8eec0382201008ce7480da41702918d1ec8e6849ba32b4d65b1e40dc669c31a1e6306b266c0000000014fb941ff552d7f5b07fe7cdb799f3a769a3818bba03ba6818615179567a75557a557a557a557a557a0079557a75547a547a547a547a757561577901c261517959795979210ac407f0e4bd44bfc207355a778b046225a7068fc59ee7eda43ad905aadbffc800206c266b30e6a1319c66dc401e5bd6b432ba49688eecd118297041da8074ce08105b795679615679aa0079610079517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e01007e81517a75615779567956795679567961537956795479577995939521414136d08c5ed2bf3ba048afe6dcaebafeffffffffffffffffffffffffffffff00517951796151795179970079009f63007952799367007968517a75517a75517a7561527a75517a517951795296a0630079527994527a75517a6853798277527982775379012080517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f517f7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e7c7e01205279947f7754537993527993013051797e527e54797e58797e527e53797e52797e57797e0079517a75517a75517a75517a75517a75517a75517a75517a75517a75517a75517a75517a75517a756100795779ac517a75517a75517a75517a75517a75517a75517a75517a75517a7561517a75517a756169577961007961007982775179517954947f75517958947f77517a75517a756161007901007e81517a7561517a7561527a75517a57796100796100798277517951790128947f755179012c947f77517a75517a756161007901007e81517a7561517a7561517a75007905ffffffff009f6951795379a2695879a95479876959795979ac77777777777777777777'
+    const i = rawTx.indexOf(lockingScript.slice(0, 100))
+    const j = rawTx.indexOf(lockingScript.slice(lockingScript.length - 100))
+    if (i >= 0 && j >= 0) {
+      const pushtx = rawTx.slice(i, j + 100)
+      expect(pushtx).toBe(lockingScript)
+    }
+    const ok = validateUnlockScript(rawTx, 0, lockingScript, 1001)
+    expect(ok).toBe(true)
+  })
+})
+
+export function validateUnlockScript (
+  spendingRawTx: string,
+  vin: number,
+  lockingScript: string,
+  amount: number
+): boolean {
+  const spendingTx = Transaction.fromHex(spendingRawTx)
+  const ls = Script.fromHex(lockingScript)
+
+  const spend = new Spend({
+    sourceTXID: verifyNotNull(spendingTx.inputs[vin].sourceTXID, 'sourceTXID must have value'),
+    sourceOutputIndex: verifyNotNull(spendingTx.inputs[vin].sourceOutputIndex, 'sourceOutputIndex must have value'),
+    sourceSatoshis: amount,
+    lockingScript: ls,
+    transactionVersion: spendingTx.version,
+    otherInputs: spendingTx.inputs.filter((v, i) => i !== vin),
+    inputIndex: vin,
+    unlockingScript: verifyNotNull(spendingTx.inputs[vin].unlockingScript, 'unlockingScript must have value'),
+    outputs: spendingTx.outputs,
+    inputSequence: verifyNotNull(spendingTx.inputs[vin].sequence, 'sequence must have value'),
+    lockTime: spendingTx.lockTime
+  })
+
+  const valid = spend.validate()
+  return valid
+}