@bsv/templates 1.1.0 → 1.2.1

package/src/MultiSigPubkeyHash.ts

@@ -0,0 +1,214 @@
+import { ScriptTemplate, LockingScript, UnlockingScript, OP, Hash, PublicKey, TransactionSignature, Signature, Utils, WalletInterface, Transaction, ScriptChunk } from "@bsv/sdk"
+
+export type MultiSigInstructions = {
+    keyID: string
+    counterparty: string
+    pubkeys: string[]
+}
+
+function concatPubkeys(pubkeys: PublicKey[]): number[] {
+    return pubkeys.map((p) => p.toDER() as number[]).reduce((a, b) => a.concat(b), [])
+}
+
+export class MultiSigPubkeyHash implements ScriptTemplate {
+
+    static address(pubkeys: PublicKey[], threshold: number): string {
+        const concat = concatPubkeys(pubkeys)
+        const hash = Hash.hash160(concat)
+        const writer = new Utils.Writer()
+        writer.write(hash)
+        writer.writeVarIntNum(threshold)
+        writer.writeVarIntNum(pubkeys.length)
+        const data = writer.toArray()
+        return Utils.toBase58Check(data, [0x98])
+    }
+
+    static async addressBRC29(wallet: WalletInterface, counterparties: string[], keyID: string, threshold: number): Promise<{ pubkeys: string[], address: string }> {
+        const pubkeys = await Promise.all(counterparties.map(async (counterparty) => {
+            const { publicKey } = await wallet.getPublicKey({
+                protocolID: [1, "multi sig brc29"],
+                keyID,
+                counterparty
+            })
+            return PublicKey.fromString(publicKey)
+        }))
+        return { pubkeys: pubkeys.map(p => p.toString()), address: this.address(pubkeys, threshold) }
+    }
+
+    static thresholdAndTotalFromAddress(address: string): { hash: number[], threshold: number, total: number } {
+        const h = Utils.fromBase58Check(address)
+        if (h.prefix[0] !== 0x98) {
+            throw new Error('only P2MSH is supported, set your prefix byte to 0x98')
+        }
+        const reader = new Utils.Reader(h.data as number[])
+        const hash = reader.read(20)
+        const threshold = reader.readVarIntNum()
+        const total = reader.readVarIntNum()
+        return { hash, threshold, total }
+    }
+
+    lock(
+        address?: string,
+        pubkeys?: PublicKey[],
+        threshold: number = 1,
+    ): LockingScript {
+        let hash: number[]
+        let total: number
+        if (address) {
+            if (typeof address !== 'string') throw new Error('address must be a string')
+            const result = MultiSigPubkeyHash.thresholdAndTotalFromAddress(address)
+            hash = result.hash
+            total = result.total
+            threshold = result.threshold
+        } else {
+            if (!pubkeys || pubkeys.length < 2 || pubkeys.length < threshold) throw new Error(`at least ${threshold} pubkeys are required, or use an address`)
+            const concat = concatPubkeys(pubkeys)
+            hash = Hash.hash160(concat)
+            total = pubkeys.length
+        }
+
+        const script = new LockingScript();
+        for (let i = 0; i < total - 1; i++) {
+            script.writeOpCode(OP.OP_CAT)
+        }
+        script
+            .writeOpCode(OP.OP_DUP)
+            .writeOpCode(OP.OP_HASH160)
+            .writeBin(hash)
+            .writeOpCode(OP.OP_EQUALVERIFY)
+            .writeNumber(threshold)
+            .writeOpCode(OP.OP_SWAP);
+        for (let i = 0; i < total - 1; i++) {
+            script
+                .writeNumber(33)
+                .writeOpCode(OP.OP_SPLIT)
+        }
+        script.writeNumber(total)
+        script.writeOpCode(OP.OP_CHECKMULTISIG);
+
+        return script
+    }
+
+    unlock(
+        wallet: WalletInterface,
+        customInstructions: MultiSigInstructions,
+        workingUnlockingScript?: UnlockingScript,
+        signOutputs: "all" | "none" | "single" = "all", 
+        anyoneCanPay = false, 
+        sourceSatoshis?: number, 
+        lockingScript?: LockingScript
+    ): {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>;
+      } {
+        return {
+            sign: async (tx: Transaction, inputIndex: number) => {
+                if (!workingUnlockingScript) {
+                        workingUnlockingScript = new UnlockingScript()
+                        workingUnlockingScript.writeOpCode(OP.OP_0)
+                        customInstructions.pubkeys.forEach((pubkey) => {
+                            workingUnlockingScript!.writeBin(PublicKey.fromString(pubkey).toDER() as number[])
+                        })
+                    }
+                    let signatureScope = TransactionSignature.SIGHASH_FORKID;
+                    if (signOutputs === "all") {
+                        signatureScope |= TransactionSignature.SIGHASH_ALL;
+                    }
+                    if (signOutputs === "none") {
+                        signatureScope |= TransactionSignature.SIGHASH_NONE;
+                    }
+                    if (signOutputs === "single") {
+                        signatureScope |= TransactionSignature.SIGHASH_SINGLE;
+                    }
+                    if (anyoneCanPay) {
+                        signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY;
+                    }
+                    const input = tx.inputs[inputIndex];
+        
+                    const otherInputs = tx.inputs.filter(
+                    (_, index) => index !== inputIndex
+                    )
+
+                const sourceTXID = input.sourceTXID
+                ? input.sourceTXID
+                : input.sourceTransaction?.id("hex");
+                if (!sourceTXID) {
+                throw new Error(
+                    "The input sourceTXID or sourceTransaction is required for transaction signing."
+                );
+                }
+                sourceSatoshis ||=
+                input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis;
+                if (!sourceSatoshis) {
+                throw new Error(
+                    "The sourceSatoshis or input sourceTransaction is required for transaction signing."
+                );
+                }
+                lockingScript ||=
+                input.sourceTransaction?.outputs[input.sourceOutputIndex]
+                    .lockingScript;
+                if (!lockingScript) {
+                throw new Error(
+                    "The lockingScript or input sourceTransaction is required for transaction signing."
+                );
+                }
+
+                const preimage = TransactionSignature.format({
+                    sourceTXID,
+                    sourceOutputIndex: input.sourceOutputIndex,
+                    sourceSatoshis,
+                    transactionVersion: tx.version,
+                    otherInputs,
+                    inputIndex,
+                    outputs: tx.outputs,
+                    inputSequence: input.sequence || 0xffffffff,
+                    subscript: lockingScript,
+                    lockTime: tx.lockTime,
+                    scope: signatureScope,
+                })
+
+                const hashToDirectlySign = Hash.hash256(preimage)
+
+                const { signature } = await wallet.createSignature({
+                    hashToDirectlySign,
+                    protocolID: [1, "multi sig brc29"],
+                    counterparty: customInstructions.counterparty,
+                    keyID: customInstructions.keyID,
+                })
+
+                const s = Signature.fromDER(signature)
+                const sig = new TransactionSignature(s.r, s.s, signatureScope)
+                const sigForScript = sig.toChecksigFormat()
+
+                workingUnlockingScript.writeBin(sigForScript)
+                const chunkforSig = workingUnlockingScript.chunks.pop() as ScriptChunk
+                // add it to the array at position 1, pushing the other content to the right
+                workingUnlockingScript.chunks.splice(1, 0, chunkforSig)
+                return workingUnlockingScript
+            },
+
+            estimateLength: (tx: Transaction, inputIndex: number) => {
+                let numberOfPubkeys = 2
+                let numberOfSignatures = 1
+                const staticLength = 28
+                const input = tx.inputs[inputIndex];
+                const lockingScript = input.sourceTransaction?.outputs[input.sourceOutputIndex].lockingScript;
+                if (!lockingScript) {
+                    return Promise.resolve(1000) // guess
+                }
+                let chunks = lockingScript.chunks.length - 8 // remove static chunks
+                const numPubKeys = Math.floor(chunks / 3)
+                const thresholdPos = 5 + (numPubKeys - 1)
+                const n = lockingScript?.chunks[thresholdPos] as { op: number, data: number[] }
+                if (!n.data) {
+                    numberOfSignatures = 1 + (n.op as number) - OP.OP_1
+                } else {
+                    const reader = new Utils.Reader(n.data)
+                    const threshold = reader.readInt64LEBn()
+                    numberOfSignatures = threshold.toNumber()
+                }
+                return Promise.resolve(staticLength + (numberOfPubkeys * 34) + (numberOfSignatures * 73))
+            }
+        }
+    }
+}

package/src/OpReturn.ts

@@ -5,7 +5,7 @@ import { OP, Script, ScriptTemplate, LockingScript, UnlockingScript, Transaction
  *
  * This class provides methods to create OpReturn scripts from data. Only lock script is available.
  */
-export default class OpReturn implements ScriptTemplate {
+export class OpReturn implements ScriptTemplate {
   /**
      * Creates an OpReturn script
      *

package/src/Metanet.ts

@@ -1,49 +0,0 @@
-import { OP, PublicKey, ScriptTemplate, LockingScript, UnlockingScript, Transaction, Utils } from '@bsv/sdk'
-
-/**
- * Metanet class implementing ScriptTemplate.
- *
- * This class provides methods to create Metanet outputs from data. Only lock script is available.
- */
-export default class Metanet implements ScriptTemplate {
-  /**
- * Creates a Metanet output script
- *
- * @param {PublicKey} pubkey the public key responsible for the metanet node
- * @param {string} parentTXID the TXID of the parent metanet transaction or null for root node
- * @param {string[]} data the output data, an array of metadata ending in data payload
- * @returns {LockingScript} - A Metanet locking script.
- *
- * @example
- * // creates a root metanet output with 'subprotocol' and 'filename' metadata followed by data
- * lock(pubkey, null, txid, ['subprotocol', 'filename', data ])
- */
-  lock (pubkey: PublicKey, parentTXID: string | null, data: string[] | string = []): LockingScript {
-    const script: Array<{ op: number, data?: number[] }> = [
-      { op: OP.OP_FALSE },
-      { op: OP.OP_RETURN }
-    ]
-
-    const fields = [
-      'meta',
-      pubkey.toString(),
-      parentTXID ?? 'null'
-    ].concat(data)
-
-    for (const field of fields.filter(Boolean)) {
-      script.push({ op: field.length, data: Utils.toArray(field) })
-    }
-
-    return new LockingScript(script)
-  }
-
-  /**
-    * Unlock method is not available for Metanet scripts, throws exception.
-    */
-  unlock (): {
-    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-    estimateLength: () => Promise<number>
-  } {
-    throw new Error('Unlock is not supported for Metanet scripts')
-  }
-}

package/src/__tests/Metanet.test.ts

@@ -1,21 +0,0 @@
-import Metanet from '../Metanet'
-import { PrivateKey, Utils } from '@bsv/sdk'
-
-describe('Metanet template', () => {
-  it('creates metanet output', () => {
-    const priv = PrivateKey.fromRandom()
-    const script = new Metanet().lock(priv.toPublicKey(), null, ['subprotocol', 'data'])
-    const tokens = script.toASM().split(' ')
-    expect(tokens[0]).toEqual('OP_0')
-    expect(tokens[1]).toEqual('OP_RETURN')
-    expect(Utils.toUTF8(Utils.toArray(tokens[2], 'hex'))).toEqual('meta')
-    expect(Utils.toUTF8(Utils.toArray(tokens[3], 'hex'))).toEqual(priv.toPublicKey().toString())
-    expect(Utils.toUTF8(Utils.toArray(tokens[4], 'hex'))).toEqual('null')
-    expect(Utils.toUTF8(Utils.toArray(tokens[5], 'hex'))).toEqual('subprotocol')
-    expect(Utils.toUTF8(Utils.toArray(tokens[6], 'hex'))).toEqual('data')
-  })
-
-  it('fails to create metanet input', () => {
-    expect(() => new Metanet().unlock()).toThrow()
-  })
-})

package/src/__tests/MultiPushDrop.test.ts

@@ -1,256 +0,0 @@
-import MultiPushDrop from '../MultiPushDrop'
-import { OP, WalletInterface, WalletCounterparty, PubKeyHex, SecurityLevel, Transaction, CompletedProtoWallet, PrivateKey, PublicKey, Utils, Script, Spend, LockingScript, UnlockingScript } from '@bsv/sdk'
-
-// Helper function like createDecodeRedeem from PushDrop tests
-const testLockUnlockDecode = async (
-  creatorMultiPushDrop: MultiPushDrop,
-  creatorWallet: WalletInterface,
-  fields: number[][],
-  protocolID: [SecurityLevel, string],
-  keyID: string,
-  ownerPrivateKeys: PrivateKey[],
-  signOutputs: 'all' | 'none' | 'single' = 'all',
-  anyoneCanPay: boolean = false
-): Promise<void> => {
-  // --- Lock ---
-  const counterparties = ownerPrivateKeys.map(x => x.toPublicKey().toString())
-  const lockingScript = await creatorMultiPushDrop.lock(
-    fields,
-    protocolID,
-    keyID,
-    counterparties
-  )
-  expect(lockingScript).toBeInstanceOf(LockingScript)
-
-  // --- Decode ---
-  const decoded = MultiPushDrop.decode(lockingScript)
-  expect(decoded.fields).toEqual(fields)
-  expect(decoded.lockingPublicKeys.length).toEqual(ownerPrivateKeys.length)
-
-  // Verify decoded keys match derived keys
-  const derivedKeys: PubKeyHex[] = []
-  for (const c of counterparties) {
-    const { publicKey } = await creatorWallet.getPublicKey({
-      protocolID, keyID, counterparty: c
-    })
-    derivedKeys.push(publicKey)
-  }
-  expect(decoded.lockingPublicKeys).toEqual(derivedKeys)
-
-  // --- Unlock (for each counterparty) ---
-  const satoshis = 1000 // Use a non-dust amount
-
-  const sourceTx = new Transaction(
-    1, [], [{ lockingScript, satoshis }], 0
-  )
-  const sourceOutputIndex = 0
-  const { publicKey: creatorIdentityKey } = await creatorWallet.getPublicKey({ identityKey: true })
-
-  for (let i = 0; i < ownerPrivateKeys.length; i++) {
-    const ownerWallet = new CompletedProtoWallet(ownerPrivateKeys[i])
-    const ownerMultiPushDrop = new MultiPushDrop(ownerWallet)
-    console.log(`Testing unlock with counterparty index ${i}`)
-
-    const unlockingTemplate = ownerMultiPushDrop.unlock(
-      protocolID,
-      keyID,
-      creatorIdentityKey,
-      signOutputs,
-      anyoneCanPay
-    )
-
-    // Create a dummy spending transaction
-    const spendTx = new Transaction(
-      1,
-      [{
-        sourceTransaction: sourceTx, // Link for signing context
-        sourceOutputIndex,
-        // unlockingScript will be added by sign method
-        sequence: 0xffffffff
-      }],
-      [{ // Dummy output
-        lockingScript: Script.fromASM('OP_RETURN'),
-        satoshis: satoshis - 500 // Account for potential fees
-      }],
-      0
-    )
-
-    // Sign to get the unlocking script
-    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
-    expect(unlockingScript).toBeInstanceOf(UnlockingScript)
-    expect(unlockingScript.chunks.length).toBe(2) // Signature + Index
-    // Verify index chunk
-    const indexChunk = unlockingScript.chunks[1]
-    let decodedIndex: number
-    if (indexChunk.op === OP.OP_0) decodedIndex = 0
-    else if (indexChunk.op >= OP.OP_1 && indexChunk.op <= OP.OP_16) decodedIndex = indexChunk.op - OP.OP_1 + 1
-    else if (indexChunk.data?.length === 1) decodedIndex = indexChunk.data[0]
-    else throw new Error('Cannot decode index')
-    expect(decodedIndex).toEqual(ownerPrivateKeys.length - 1 - i) // It should be nKeys - 1 - the loop count
-
-    const estimatedLength = await unlockingTemplate.estimateLength(null as unknown as Transaction, 0)
-    // Check if length is reasonable (e.g., 74 +/- a few bytes)
-    expect(estimatedLength).toBeGreaterThanOrEqual(72)
-    expect(estimatedLength).toBeLessThanOrEqual(80)
-
-    // --- Verify Spend ---
-    const spend = new Spend({
-      sourceTXID: sourceTx.id('hex'),
-      sourceOutputIndex,
-      sourceSatoshis: satoshis,
-      lockingScript, // From lock step
-      transactionVersion: spendTx.version,
-      otherInputs: [], // No other inputs in this simple case
-      inputIndex: 0,
-      unlockingScript, // From sign step
-      outputs: spendTx.outputs,
-      inputSequence: spendTx.inputs[0].sequence ?? 0xffffffff,
-      lockTime: spendTx.lockTime
-    })
-    const valid = spend.validate()
-    expect(valid).toBe(true)
-  }
-}
-
-describe('MultiPushDrop', () => {
-  let selfKey: PrivateKey
-  let wallet: WalletInterface
-  let multiPushDrop: MultiPushDrop
-  let counterparty1Key: PrivateKey
-  let counterparty2Key: PrivateKey
-  const protocolID: [SecurityLevel, string] = [0, 'tests']
-  const keyID = 'test-key-123'
-
-  beforeEach(() => {
-    selfKey = PrivateKey.fromRandom()
-    counterparty1Key = PrivateKey.fromRandom()
-    counterparty2Key = PrivateKey.fromRandom()
-
-    // Use CompletedProtoWallet or mock as needed
-    wallet = new CompletedProtoWallet(selfKey)
-    multiPushDrop = new MultiPushDrop(wallet)
-  })
-
-  it('should lock, decode, and unlock with a single key (self)', async () => {
-    await testLockUnlockDecode(
-      multiPushDrop,
-      wallet,
-      [[1, 2, 3]],
-      protocolID,
-      keyID,
-      [selfKey]
-    )
-  })
-
-  it('should lock, decode, and unlock with a single key (external)', async () => {
-    await testLockUnlockDecode(
-      multiPushDrop,
-      wallet,
-      [[0xaa, 0xbb]],
-      protocolID,
-      keyID,
-      [counterparty1Key]
-    )
-  })
-
-  it('should lock, decode, and unlock with two keys (self, external)', async () => {
-    await testLockUnlockDecode(
-      multiPushDrop,
-      wallet,
-      [Utils.toArray('hello', 'utf8')],
-      protocolID,
-      keyID,
-      [counterparty1Key, selfKey]
-    )
-  })
-
-  it('should lock, decode, and unlock with three keys (self, external1, external2)', async () => {
-    await testLockUnlockDecode(
-      multiPushDrop,
-      wallet,
-      [[1], [1], [0xff]],
-      protocolID,
-      keyID,
-      [selfKey, counterparty1Key, counterparty2Key]
-    )
-  })
-
-  it('should lock, decode, and unlock with 10 keys', async () => {
-    const keys: PrivateKey[] = []
-    while (keys.length < 10) {
-      keys.push(PrivateKey.fromRandom())
-    }
-    await testLockUnlockDecode(
-      multiPushDrop,
-      wallet,
-      [[1], [1], [0xff]],
-      protocolID,
-      keyID,
-      keys
-    )
-  })
-
-  it('should handle empty fields', async () => {
-    await testLockUnlockDecode(
-      multiPushDrop,
-      wallet,
-      [],
-      protocolID,
-      keyID,
-      [selfKey, counterparty1Key]
-    )
-  })
-
-  it('should handle large fields', async () => {
-    await testLockUnlockDecode(
-      multiPushDrop,
-      wallet,
-      [new Array(100).fill(0xaa), new Array(80).fill(0xbb), new Array(70000).fill(0xbb)],
-      protocolID,
-      keyID,
-      [selfKey, counterparty1Key]
-    )
-  })
-
-  it('should handle different signOutputs modes (anyonecanpay=false)', async () => {
-    const counterparties = [selfKey, counterparty1Key]
-    const fields = [[1]]
-    await testLockUnlockDecode(multiPushDrop, wallet, fields, protocolID, keyID, counterparties, 'all', false)
-    await testLockUnlockDecode(multiPushDrop, wallet, fields, protocolID, keyID, counterparties, 'none', false)
-    await testLockUnlockDecode(multiPushDrop, wallet, fields, protocolID, keyID, counterparties, 'single', false)
-  })
-
-  it('should handle different signOutputs modes (anyonecanpay=true)', async () => {
-    const counterparties = [selfKey, counterparty1Key]
-    const fields = [[2]]
-    await testLockUnlockDecode(multiPushDrop, wallet, fields, protocolID, keyID, counterparties, 'all', true)
-    await testLockUnlockDecode(multiPushDrop, wallet, fields, protocolID, keyID, counterparties, 'none', true)
-    await testLockUnlockDecode(multiPushDrop, wallet, fields, protocolID, keyID, counterparties, 'single', true)
-  })
-
-  it('lock should fail with empty counterparties array', async () => {
-    await expect(multiPushDrop.lock(
-      [[1]],
-      protocolID,
-      keyID,
-      []
-    )).rejects.toThrow('MultiPushDrop requires at least one counterparty.')
-  })
-
-  it('unlock should fail if unlocker key is not in the list', async () => {
-    const { publicKey: creatorIdentityKey } = await wallet.getPublicKey({ identityKey: true })
-    const lockingScript = await multiPushDrop.lock([[1]], protocolID, keyID, ['self'])
-    const sourceTx = new Transaction(1, [], [{ lockingScript, satoshis: 1000 }], 0)
-    const spendTx = new Transaction(1, [{ sourceTransaction: sourceTx, sourceOutputIndex: 0 }], [], 0)
-
-    const unknownKey = PrivateKey.fromRandom()
-    const walletWithUnknown = new CompletedProtoWallet(unknownKey)
-    const mpdAsUnknown = new MultiPushDrop(walletWithUnknown)
-    const unlockingTemplate = mpdAsUnknown.unlock(
-      protocolID,
-      keyID,
-      creatorIdentityKey
-    )
-    await expect(unlockingTemplate.sign(spendTx, 0)).rejects.toThrow(/Unlocker key derived .* not found/)
-  })
-})

package/src/__tests/OpReturn.test.ts

@@ -1,11 +0,0 @@
-import OpReturn from '../OpReturn'
-
-describe('OpReturn script', () => {
-  it('locks OpReturn data', () => {
-    expect(new OpReturn().lock('1234').toASM()).toEqual('OP_0 OP_RETURN 31323334')
-    expect(new OpReturn().lock(['1234', '5678']).toASM()).toEqual('OP_0 OP_RETURN 31323334 35363738')
-  })
-  it('does not support unlocking', () => {
-    expect(() => new OpReturn().unlock()).toThrow()
-  })
-})