@bsv/templates 1.2.2 → 1.3.0

package/src/MultiSigPubkeyHash.ts

@@ -10,9 +10,23 @@ function concatPubkeys(pubkeys: PublicKey[]): number[] {
     return pubkeys.map((p) => p.toDER() as number[]).reduce((a, b) => a.concat(b), [])
 }
 
+function numberFromScriptChunk(chunk: ScriptChunk): number {
+    let returnNum: number
+    if (!chunk.data) {
+        returnNum = 1 + (chunk.op as number) - OP.OP_1
+    } else {
+        const reader = new Utils.Reader(chunk.data)
+        const threshold = reader.readInt64LEBn()
+        returnNum = threshold.toNumber()
+    }
+    return returnNum
+}
+
 export class MultiSigPubkeyHash implements ScriptTemplate {
 
     static address(pubkeys: PublicKey[], threshold: number): string {
+        if (threshold < 1 || threshold > pubkeys.length) throw new Error('threshold must be between 1 and the number of pubkeys')
+        if (!pubkeys || pubkeys.length < 2 || pubkeys.length < threshold) throw new Error(`at least ${threshold || 2} pubkeys are required`)
         const concat = concatPubkeys(pubkeys)
         const hash = Hash.hash160(concat)
         const writer = new Utils.Writer()
@@ -51,9 +65,9 @@ export class MultiSigPubkeyHash implements ScriptTemplate {
         address?: string,
         pubkeys?: PublicKey[],
         threshold: number = 1,
-    ): LockingScript {
+    ): LockingScript {        
         let hash: number[]
-        let total: number
+        let total: number = pubkeys?.length || 0
         if (address) {
             if (typeof address !== 'string') throw new Error('address must be a string')
             const result = MultiSigPubkeyHash.thresholdAndTotalFromAddress(address)
@@ -61,12 +75,13 @@ export class MultiSigPubkeyHash implements ScriptTemplate {
             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`)
+            if (!pubkeys || total < 2) throw new Error(`at least 2 pubkeys are required`)
             const concat = concatPubkeys(pubkeys)
             hash = Hash.hash160(concat)
-            total = pubkeys.length
         }
-
+        if (!threshold || threshold < 1 || threshold > total) throw new Error('threshold must be between 1 and the number of pubkeys')
+        if (total > 10) throw new Error('total must be less than or equal to 10')
+    
         const script = new LockingScript();
         for (let i = 0; i < total - 1; i++) {
             script.writeOpCode(OP.OP_CAT)
@@ -104,53 +119,52 @@ export class MultiSigPubkeyHash implements ScriptTemplate {
         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
-                    )
+                    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");
+                    ? input.sourceTXID
+                    : input.sourceTransaction?.id("hex")
+                
                 if (!sourceTXID) {
-                throw new Error(
-                    "The input sourceTXID or sourceTransaction is required for transaction signing."
-                );
+                    throw new Error(
+                        "The input sourceTXID or sourceTransaction is required for transaction signing."
+                    )
                 }
-                sourceSatoshis ||=
-                input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis;
+                sourceSatoshis ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis;
                 if (!sourceSatoshis) {
-                throw new Error(
-                    "The sourceSatoshis or input sourceTransaction is required for transaction signing."
-                );
+                    throw new Error(
+                        "The sourceSatoshis or input sourceTransaction is required for transaction signing."
+                    )
                 }
-                lockingScript ||=
-                input.sourceTransaction?.outputs[input.sourceOutputIndex]
-                    .lockingScript;
+                lockingScript ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].lockingScript;
                 if (!lockingScript) {
-                throw new Error(
-                    "The lockingScript or input sourceTransaction is required for transaction signing."
-                );
+                    throw new Error(
+                        "The lockingScript or input sourceTransaction is required for transaction signing."
+                    )
                 }
 
                 const preimage = TransactionSignature.format({
@@ -182,32 +196,28 @@ export class MultiSigPubkeyHash implements ScriptTemplate {
 
                 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)
+                // add it to the array before the pubkeys, pushing the other content to the right
+                workingUnlockingScript.chunks.splice(workingUnlockingScript.chunks.length - customInstructions.pubkeys.length, 0, chunkforSig)
                 return workingUnlockingScript
             },
 
             estimateLength: (tx: Transaction, inputIndex: number) => {
                 let numberOfPubkeys = 2
                 let numberOfSignatures = 1
-                const staticLength = 28
+                const staticLength = 1
                 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))
+
+                const totalChunk = lockingScript?.chunks[lockingScript.chunks.length - 2] as { op: number, data: number[] }
+                numberOfPubkeys = numberFromScriptChunk(totalChunk)
+
+                const thresholdPos = lockingScript.chunks.map(chunk => chunk.op === OP.OP_EQUALVERIFY).indexOf(true) + 1
+                const thresholdChunk = lockingScript?.chunks[thresholdPos] as { op: number, data: number[] }
+                numberOfSignatures = numberFromScriptChunk(thresholdChunk)
+                return Promise.resolve(staticLength + (numberOfSignatures * 74) +   (numberOfPubkeys * 34))
             }
         }
     }