@bsv/templates 1.6.1 → 1.7.1

package/src/MandalaToken.ts

@@ -5,7 +5,7 @@ import {
 } from '@bsv/sdk'
 import {
   createMinimallyEncodedScriptChunk, encodeScriptNum, decodeScriptNumChunk,
-  encodeAssetId, decodeAssetId, MARKER
+  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 = decodeScriptNumChunk(c[2])
+    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,57 @@
 import { MandalaAdmin } from '../MandalaAdmin.js'
-import { PrivateKey, OP } from '@bsv/sdk'
+import { ProtoWallet, PrivateKey, OP, Utils } 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()
+  })
+
+  it('embeds publicData as <push JSON> OP_DROP before the P2PKH', async () => {
+    const script = await MandalaAdmin.lock({ wallet: wallet as any, data, publicData: { label: 'Gold' } })
+    const ops = script.chunks.map(c => c.op)
+    expect(ops.slice(1)).toEqual([OP.OP_DROP, OP.OP_DUP, OP.OP_HASH160, 20, OP.OP_EQUALVERIFY, OP.OP_CHECKSIG])
+    expect(JSON.parse(Utils.toUTF8(script.chunks[0].data as number[]))).toEqual({ label: 'Gold' })
+  })
+
+  it('decode round-trips publicData and pubKeyHash (7-chunk)', async () => {
+    const script = await MandalaAdmin.lock({ wallet: wallet as any, data, publicData: { label: 'Gold', ticker: 'GLD' } })
+    const decoded = MandalaAdmin.decode(script)
+    expect(decoded.pubKeyHash).toEqual(script.chunks[4].data)
+    expect(decoded.publicData).toEqual({ label: 'Gold', ticker: 'GLD' })
+  })
+
+  it('decode returns no publicData for a plain 5-chunk admin script', async () => {
+    const script = await MandalaAdmin.lock({ wallet: wallet as any, data })
+    const decoded = MandalaAdmin.decode(script)
+    expect(decoded.pubKeyHash).toEqual(script.chunks[2].data)
+    expect(decoded.publicData).toBeUndefined()
+  })
+
+  it('decode rejects a 7-chunk script whose second op is not OP_DROP', async () => {
+    const script = await MandalaAdmin.lock({ wallet: wallet as any, data, publicData: { label: 'X' } })
+    script.chunks[1] = { op: OP.OP_DUP }
     expect(() => MandalaAdmin.decode(script)).toThrow()
   })
 })

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

@@ -0,0 +1,80 @@
+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('CHECKSIG verifies a publicData admin output (prefix is dropped)', async () => {
+    const wallet = new ProtoWallet(PrivateKey.fromRandom())
+    const lock = await MandalaAdmin.lock({ wallet: wallet as any, data, publicData: { label: 'Gold' } })
+
+    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

@@ -43,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,6 +1,6 @@
 import {
   createMinimallyEncodedScriptChunk, encodeScriptNum, decodeScriptNum,
-  decodeScriptNumChunk, encodeAssetId, decodeAssetId, MARKER
+  decodeScriptNumChunk, encodeAssetId, decodeAssetId
 } from '../mandala-encoding'
 
 describe('mandala-encoding', () => {
@@ -35,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[] } => {