@bsv/templates 1.6.0 → 1.7.0

package/src/MandalaToken.ts

@@ -4,8 +4,8 @@ import {
   TransactionSignature, PrivateKey
 } from '@bsv/sdk'
 import {
-  createMinimallyEncodedScriptChunk, encodeScriptNum, decodeScriptNum,
-  encodeAssetId, decodeAssetId, MARKER
+  createMinimallyEncodedScriptChunk, encodeScriptNum, decodeScriptNumChunk,
+  encodeAssetId, decodeAssetId
 } from './mandala-encoding.js'
 import { buildSighashPreimage } from './mandala-signing.js'
 
@@ -47,12 +47,12 @@ export class MandalaToken implements ScriptTemplate {
     if (pubKeyHash.length !== 20) throw new Error('pubKeyHash must be 20 bytes')
     if (!Number.isInteger(amount) || amount < 1) throw new Error('amount must be a positive integer')
     const assetIdBytes = encodeAssetId(assetId)
+    // assetId + amount are pushed then dropped by a single OP_2DROP; the tail is
+    // a standard P2PKH. No identifier prefix — outputs are classified off-chain.
     return new LockingScript([
-      createMinimallyEncodedScriptChunk([MARKER]),
       createMinimallyEncodedScriptChunk(assetIdBytes),
       createMinimallyEncodedScriptChunk(encodeScriptNum(amount)),
       { op: OP.OP_2DROP },
-      { op: OP.OP_DROP },
       { op: OP.OP_DUP },
       { op: OP.OP_HASH160 },
       { op: pubKeyHash.length, data: pubKeyHash },
@@ -85,17 +85,15 @@ export class MandalaToken implements ScriptTemplate {
 
   static decode (script: LockingScript): MandalaTokenDecoded {
     const c = script.chunks
-    if (c.length !== 10) throw new Error('not a MandalaToken script: wrong chunk count')
-    const marker = c[0].data ?? []
-    if (c[0].op !== 1 || marker.length !== 1 || marker[0] !== MARKER) throw new Error('not a MandalaToken script: missing marker')
-    if (c[3].op !== OP.OP_2DROP || c[4].op !== OP.OP_DROP) throw new Error('not a MandalaToken script: bad drops')
-    if (c[5].op !== OP.OP_DUP || c[6].op !== OP.OP_HASH160 || c[8].op !== OP.OP_EQUALVERIFY || c[9].op !== OP.OP_CHECKSIG) {
+    if (c.length !== 8) throw new Error('not a MandalaToken script: wrong chunk count')
+    if (c[2].op !== OP.OP_2DROP) throw new Error('not a MandalaToken script: bad drops')
+    if (c[3].op !== OP.OP_DUP || c[4].op !== OP.OP_HASH160 || c[6].op !== OP.OP_EQUALVERIFY || c[7].op !== OP.OP_CHECKSIG) {
       throw new Error('not a MandalaToken script: bad P2PKH tail')
     }
-    const assetId = decodeAssetId(vt(c[1].data))
-    const amount = decodeScriptNum(c[2].data ?? [])
+    const assetId = decodeAssetId(vt(c[0].data))
+    const amount = decodeScriptNumChunk(c[1])
     if (!Number.isInteger(amount) || amount < 1) throw new Error('not a MandalaToken script: bad amount')
-    const pubKeyHash = vt(c[7].data)
+    const pubKeyHash = vt(c[5].data)
     if (pubKeyHash.length !== 20) throw new Error('not a MandalaToken script: bad pubKeyHash')
     return { assetId, amount, pubKeyHash }
   }

package/src/__tests/MandalaAdmin.derive.test.ts

@@ -1,4 +1,4 @@
-import { MandalaAdmin } from '../MandalaAdmin.js'
+import { MandalaAdmin, ADMIN_PROTOCOL } from '../MandalaAdmin.js'
 
 describe('MandalaAdmin canonicalize/commitment', () => {
   it('is insensitive to key ordering', () => {
@@ -18,17 +18,15 @@ describe('MandalaAdmin canonicalize/commitment', () => {
     expect(c).toBe(MandalaAdmin.commitment({ assetId: 'x.0', kind: 'register' } as any))
   })
 
-  it('derives a boundKey via getPublicKey with counterparty anyone', async () => {
+  it('locks the output to keyID = commitment(data) with counterparty self by default', async () => {
     const calls: any[] = []
     const wallet: any = {
       getPublicKey: async (args: any) => { calls.push(args); return { publicKey: '02' + 'a'.repeat(64) } }
     }
-    const admin = new MandalaAdmin(wallet)
-    const details = { kind: 'issue', assetId: 'x.0', amount: 10 } as const
-    const { boundKey, keyID } = await admin.deriveBoundKey([2, 'mandala admin'], details)
-    expect(boundKey).toBe('02' + 'a'.repeat(64))
-    expect(keyID).toBe(MandalaAdmin.commitment(details))
-    expect(calls[0].counterparty).toBe('anyone')
-    expect(calls[0].keyID).toBe(keyID)
+    const data = { kind: 'issue', assetId: 'x.0', amount: 10 } as const
+    await MandalaAdmin.lock({ wallet, data })
+    expect(calls[0].protocolID).toEqual(ADMIN_PROTOCOL)
+    expect(calls[0].keyID).toBe(MandalaAdmin.commitment(data))
+    expect(calls[0].counterparty).toBe('self')
   })
 })

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

@@ -1,26 +1,30 @@
 import { MandalaAdmin } from '../MandalaAdmin.js'
-import { PrivateKey, OP } from '@bsv/sdk'
+import { ProtoWallet, PrivateKey, OP } from '@bsv/sdk'
 
 describe('MandalaAdmin lock/decode', () => {
-  it('round-trips the boundKey and has the ! OP_DROP <key> OP_CHECKSIG shape', () => {
-    const boundKey = PrivateKey.fromRandom().toPublicKey().toString()
-    const admin = new MandalaAdmin({} as any)
-    const script = admin.lock(boundKey)
+  const wallet = new ProtoWallet(PrivateKey.fromRandom())
+  const data = { kind: 'register', assetId: `${'a'.repeat(64)}.0` } as const
+
+  it('builds a standard P2PKH script (OP_DUP OP_HASH160 <20> OP_EQUALVERIFY OP_CHECKSIG)', async () => {
+    const script = await MandalaAdmin.lock({ wallet: wallet as any, data })
     const ops = script.chunks.map(c => c.op)
-    expect(script.chunks[0].data).toEqual([0x21])
-    expect(ops[1]).toBe(OP.OP_DROP)
-    expect(ops[3]).toBe(OP.OP_CHECKSIG)
-    expect(MandalaAdmin.decode(script).boundKey).toBe(boundKey)
+    expect(ops).toEqual([OP.OP_DUP, OP.OP_HASH160, 20, OP.OP_EQUALVERIFY, OP.OP_CHECKSIG])
+    expect(script.chunks[2].data?.length).toBe(20)
+  })
+
+  it('decode returns the pubKeyHash', async () => {
+    const script = await MandalaAdmin.lock({ wallet: wallet as any, data })
+    const decoded = MandalaAdmin.decode(script)
+    expect(decoded.pubKeyHash).toEqual(script.chunks[2].data)
   })
 
   it('decode throws on non-admin scripts', () => {
     expect(() => MandalaAdmin.decode({ chunks: [{ op: 0x00 }] } as any)).toThrow()
   })
 
-  it('decode rejects a non-minimal (PUSHDATA1) marker encoding', () => {
-    const boundKey = PrivateKey.fromRandom().toPublicKey().toString()
-    const script = new MandalaAdmin({} as any).lock(boundKey)
-    script.chunks[0] = { op: 0x4c, data: [0x21] }
+  it('decode throws when the hash push is not 20 bytes', async () => {
+    const script = await MandalaAdmin.lock({ wallet: wallet as any, data })
+    script.chunks[2] = { op: 19, data: new Array(19).fill(1) }
     expect(() => MandalaAdmin.decode(script)).toThrow()
   })
 })

package/src/__tests/MandalaAdmin.spend.test.ts

@@ -0,0 +1,64 @@
+import { MandalaAdmin } from '../MandalaAdmin.js'
+import { ProtoWallet, PrivateKey, Transaction, Spend, LockingScript, OP } from '@bsv/sdk'
+
+// End-to-end script test: a P2PKH admin-auth output locked by MandalaAdmin.lock
+// must be spendable by MandalaAdmin.unlock. The lock hashes the counterparty-child
+// public key (forSelf:false); unlock signs with the matching private key and pushes
+// its forSelf:true public key. By BRC-42 symmetry these are the same point, so
+// OP_HASH160 / OP_CHECKSIG pass — for self-spend and for transfer to a new admin.
+describe('MandalaAdmin spend round-trip (interpreter)', () => {
+  const data = { kind: 'issue', assetId: `${'a'.repeat(64)}.0`, amount: 5 } as const
+
+  const buildSpend = (lock: LockingScript, unlock: any, spendTx: Transaction, srcTx: Transaction): Spend =>
+    new Spend({
+      sourceTXID: srcTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: 1,
+      lockingScript: lock,
+      transactionVersion: spendTx.version,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript: unlock,
+      outputs: spendTx.outputs,
+      inputSequence: 0xffffffff,
+      lockTime: spendTx.lockTime
+    })
+
+  it('CHECKSIG verifies a self-locked, self-spent admin auth output', async () => {
+    const wallet = new ProtoWallet(PrivateKey.fromRandom())
+    const lock = await MandalaAdmin.lock({ wallet: wallet as any, data })
+
+    const srcTx = new Transaction()
+    srcTx.addOutput({ lockingScript: lock, satoshis: 1 })
+    const spendTx = new Transaction()
+    spendTx.addInput({ sourceTransaction: srcTx, sourceOutputIndex: 0, sequence: 0xffffffff })
+    spendTx.addOutput({ lockingScript: new LockingScript([{ op: OP.OP_TRUE }]), satoshis: 1 })
+
+    spendTx.inputs[0].unlockingScriptTemplate = MandalaAdmin.unlock({ wallet: wallet as any, data })
+    await spendTx.sign()
+
+    expect(buildSpend(lock, spendTx.inputs[0].unlockingScript!, spendTx, srcTx).validate()).toBe(true)
+  })
+
+  it('transfers admin: granter locks to a new admin who spends it', async () => {
+    const granter = new ProtoWallet(PrivateKey.fromRandom())
+    const newAdmin = new ProtoWallet(PrivateKey.fromRandom())
+    const { publicKey: granterId } = await granter.getPublicKey({ identityKey: true })
+    const { publicKey: newAdminId } = await newAdmin.getPublicKey({ identityKey: true })
+
+    // Granter locks the auth output to the new admin (counterparty = new admin id).
+    const lock = await MandalaAdmin.lock({ wallet: granter as any, data, counterparty: newAdminId })
+
+    const srcTx = new Transaction()
+    srcTx.addOutput({ lockingScript: lock, satoshis: 1 })
+    const spendTx = new Transaction()
+    spendTx.addInput({ sourceTransaction: srcTx, sourceOutputIndex: 0, sequence: 0xffffffff })
+    spendTx.addOutput({ lockingScript: new LockingScript([{ op: OP.OP_TRUE }]), satoshis: 1 })
+
+    // New admin spends, deriving against the granter's identity.
+    spendTx.inputs[0].unlockingScriptTemplate = MandalaAdmin.unlock({ wallet: newAdmin as any, data, counterparty: granterId })
+    await spendTx.sign()
+
+    expect(buildSpend(lock, spendTx.inputs[0].unlockingScript!, spendTx, srcTx).validate()).toBe(true)
+  })
+})

package/src/__tests/MandalaToken.test.ts

@@ -13,6 +13,22 @@ describe('MandalaToken lock/decode', () => {
     expect(decoded.pubKeyHash).toEqual(pubKeyHash)
   })
 
+  // Regression: amounts 1..16 are minimally encoded as OP_1..OP_16 opcodes (no
+  // data bytes) by createMinimallyEncodedScriptChunk. decode must read those
+  // back, not mis-read them as 0 and reject the script as a bad amount.
+  it('round-trips small amounts encoded as OP_N opcodes (1..16)', () => {
+    for (let amount = 1; amount <= 16; amount++) {
+      const script = new MandalaToken().lock(assetId, amount, pubKeyHash)
+      const decoded = MandalaToken.decode(script)
+      expect(decoded.amount).toBe(amount)
+    }
+  })
+
+  it('round-trips the boundary amount 17 (first data-push encoding)', () => {
+    const decoded = MandalaToken.decode(new MandalaToken().lock(assetId, 17, pubKeyHash))
+    expect(decoded.amount).toBe(17)
+  })
+
   it('produces a P2PKH tail (OP_DUP OP_HASH160 ... OP_EQUALVERIFY OP_CHECKSIG)', () => {
     const script = new MandalaToken().lock(assetId, 1, pubKeyHash)
     const ops = script.chunks.map(c => c.op)
@@ -27,17 +43,14 @@ describe('MandalaToken lock/decode', () => {
     const assetId = `${'a'.repeat(64)}.0`
     const pkh = new Array(20).fill(1)
     const script = new MandalaToken().lock(assetId, 5, pkh)
-    // Replace the amount push (chunk index 2) with an empty (OP_0) push.
-    script.chunks[2] = { op: 0 }
+    // Replace the amount push (chunk index 1) with an empty (OP_0) push.
+    script.chunks[1] = { op: 0 }
     expect(() => MandalaToken.decode(script)).toThrow()
   })
 
-  it('decode rejects a non-minimal (PUSHDATA1) marker encoding', () => {
-    const assetId = `${'a'.repeat(64)}.0`
-    const pkh = new Array(20).fill(1)
-    const script = new MandalaToken().lock(assetId, 5, pkh)
-    // Re-encode the marker push (chunk 0) as PUSHDATA1 of the same byte.
-    script.chunks[0] = { op: 0x4c, data: [0x21] }
-    expect(() => MandalaToken.decode(script)).toThrow()
+  it('has no identifier prefix (8 chunks, leads with the assetId push)', () => {
+    const script = new MandalaToken().lock(assetId, 1, pubKeyHash)
+    expect(script.chunks).toHaveLength(8)
+    expect(script.chunks[0].data?.length).toBe(36) // assetId bytes, not a marker
   })
 })

package/src/__tests/mandala-encoding.test.ts

@@ -1,5 +1,6 @@
 import {
-  encodeScriptNum, decodeScriptNum, encodeAssetId, decodeAssetId, MARKER
+  createMinimallyEncodedScriptChunk, encodeScriptNum, decodeScriptNum,
+  decodeScriptNumChunk, encodeAssetId, decodeAssetId
 } from '../mandala-encoding'
 
 describe('mandala-encoding', () => {
@@ -9,6 +10,15 @@ describe('mandala-encoding', () => {
     }
   })
 
+  it('decodeScriptNumChunk reads both OP_N opcodes and data pushes', () => {
+    // -1, 0 and 1..16 collapse to opcodes with no data; decodeScriptNumChunk
+    // must recover them, and still read larger data-push amounts.
+    for (const n of [-1, 0, 1, 2, 15, 16, 17, 100, 1000, 0x7fffffff]) {
+      const chunk = createMinimallyEncodedScriptChunk(encodeScriptNum(n))
+      expect(decodeScriptNumChunk(chunk)).toBe(n)
+    }
+  })
+
   it('encodes zero as an empty array', () => {
     expect(encodeScriptNum(0)).toEqual([])
   })
@@ -25,8 +35,4 @@ describe('mandala-encoding', () => {
     const assetId = `${'a'.repeat(64)}.4294967295`
     expect(decodeAssetId(encodeAssetId(assetId))).toBe(assetId)
   })
-
-  it('exposes the ! marker', () => {
-    expect(MARKER).toBe(0x21)
-  })
 })

package/src/mandala-encoding.ts

@@ -1,7 +1,5 @@
 import { Utils } from '@bsv/sdk'
 
-export const MARKER = 0x21
-
 export const createMinimallyEncodedScriptChunk = (
   data: number[]
 ): { op: number, data?: number[] } => {
@@ -43,6 +41,18 @@ export const decodeScriptNum = (data: number[]): number => {
   return result
 }
 
+// Reads a Bitcoin script number from a chunk that may be either a data push or a
+// minimally-encoded small-integer opcode. createMinimallyEncodedScriptChunk
+// collapses 0, -1 and 1..16 to OP_0 / OP_1NEGATE / OP_1..OP_16 (no data bytes),
+// so a decoder that only reads chunk.data would mis-read those as 0. This reads
+// both encodings symmetrically.
+export const decodeScriptNumChunk = (chunk: { op: number, data?: number[] }): number => {
+  if (chunk.op === 0) return 0 // OP_0 / OP_FALSE
+  if (chunk.op === 0x4f) return -1 // OP_1NEGATE
+  if (chunk.op >= 0x51 && chunk.op <= 0x60) return chunk.op - 0x50 // OP_1..OP_16
+  return decodeScriptNum(chunk.data ?? [])
+}
+
 export const encodeAssetId = (assetId: string): number[] => {
   const dot = assetId.lastIndexOf('.')
   if (dot === -1) throw new Error('assetId must be "<txid>.<vout>"')