@bsv/sdk 1.1.22 → 1.1.23

package/src/compat/BSM.ts

@@ -30,11 +30,18 @@ export const magicHash = (messageBuf: number[]): number[] => {
  * @deprecated Replaced by BRC-77 which employs BRC-42 key derivation and BRC-43 invoice numbers for enhanced security and privacy.
  * @param message The message to be signed as a number array.
  * @param privateKey The private key used for signing the message.
- * @returns The signature object.
+ * @param mode The mode of operation. When "base64", the BSM format signature is returned. When "raw", a Signature object is returned. Default: "base64".
+ * @returns The signature object when in raw mode, or the BSM base64 string when in base64 mode.
  */
-export const sign = (message: number[], privateKey: PrivateKey): Signature => {
+export const sign = (message: number[], privateKey: PrivateKey, mode: 'raw' | 'base64' = 'base64'): Signature | string => {
   const hashBuf = magicHash(message)
-  return ECDSA.sign(new BigNumber(hashBuf), privateKey, true)
+  const sig = ECDSA.sign(new BigNumber(hashBuf), privateKey, true)
+  if (mode === 'raw') {
+    return sig
+  }
+  const h = new BigNumber(hashBuf)
+  const r = sig.CalculateRecoveryFactor(privateKey.toPublicKey(), h)
+  return sig.toCompact(r, true, 'base64') as string
 }
 
 /**

package/src/compat/__tests/BSM.test.ts

@@ -17,16 +17,21 @@ describe('BSM', () => {
     const messageBuf = toArray('this is my message', 'utf8')
     const privateKey = new PrivateKey(42)
     it('should return a signature', () => {
-      const sig = sign(messageBuf, privateKey).toDER()
+      const sig = sign(messageBuf, privateKey, 'raw').toDER()
       expect(sig.length).toEqual(70)
     })
+    it('Creates the correct base64 signature', () => {
+      const privateKey = PrivateKey.fromWif("L211enC224G1kV8pyyq7bjVd9SxZebnRYEzzM3i7ZHCc1c5E7dQu")
+      const sig = sign(toArray('hello world', 'utf8'), privateKey, 'base64')
+      expect(sig).toEqual('H4T8Asr0WkC6wYfBESR6pCAfECtdsPM4fwiSQ2qndFi8dVtv/mrOFaySx9xQE7j24ugoJ4iGnsRwAC8QwaoHOXk=')
+    })
   })
   describe('verify', () => {
     const messageBuf = toArray('this is my message', 'utf8')
     const privateKey = new PrivateKey(42)
 
     it('should verify a signed message', () => {
-      const sig = sign(messageBuf, privateKey)
+      const sig = sign(messageBuf, privateKey, 'raw')
       expect(verify(messageBuf, sig, privateKey.toPublicKey())).toEqual(true)
     })
     it('Should verify a signed message in base64', () => {

package/src/primitives/utils.ts

@@ -662,3 +662,46 @@ export class Reader {
     }
   }
 }
+
+export const minimallyEncode = (buf: number[]): number[] => {
+  if (buf.length === 0) {
+    return buf
+  }
+
+  // If the last byte is not 0x00 or 0x80, we are minimally encoded.
+  const last = buf[buf.length - 1]
+  if ((last & 0x7f) !== 0) {
+    return buf
+  }
+
+  // If the script is one byte long, then we have a zero, which encodes as an
+  // empty array.
+  if (buf.length === 1) {
+    return []
+  }
+
+  // If the next byte has it sign bit set, then we are minimaly encoded.
+  if ((buf[buf.length - 2] & 0x80) !== 0) {
+    return buf
+  }
+
+  // We are not minimally encoded, we need to figure out how much to trim.
+  for (let i = buf.length - 1; i > 0; i--) {
+    // We found a non zero byte, time to encode.
+    if (buf[i - 1] !== 0) {
+      if ((buf[i - 1] & 0x80) !== 0) {
+        // We found a byte with it sign bit set so we need one more
+        // byte.
+        buf[i++] = last
+      } else {
+        // the sign bit is clear, we can use it.
+        buf[i - 1] |= last
+      }
+
+      return buf.slice(0, i)
+    }
+  }
+
+  // If we found the whole thing is zeros, then we have a zero.
+  return []
+}

package/src/script/Spend.ts

@@ -4,7 +4,7 @@ import Script from './Script.js'
 import BigNumber from '../primitives/BigNumber.js'
 import OP from './OP.js'
 import ScriptChunk from './ScriptChunk.js'
-import { toHex } from '../primitives/utils.js'
+import { toHex, minimallyEncode } from '../primitives/utils.js'
 import * as Hash from '../primitives/Hash.js'
 import TransactionSignature from '../primitives/TransactionSignature.js'
 import PublicKey from '../primitives/PublicKey.js'
@@ -206,49 +206,6 @@ export default class Spend {
       return true
     }
 
-    const minimallyEncode = (buf: number[]): number[] => {
-      if (buf.length === 0) {
-        return buf
-      }
-
-      // If the last byte is not 0x00 or 0x80, we are minimally encoded.
-      const last = buf[buf.length - 1]
-      if ((last & 0x7f) !== 0) {
-        return buf
-      }
-
-      // If the script is one byte long, then we have a zero, which encodes as an
-      // empty array.
-      if (buf.length === 1) {
-        return []
-      }
-
-      // If the next byte has it sign bit set, then we are minimaly encoded.
-      if ((buf[buf.length - 2] & 0x80) !== 0) {
-        return buf
-      }
-
-      // We are not minimally encoded, we need to figure out how much to trim.
-      for (let i = buf.length - 1; i > 0; i--) {
-        // We found a non zero byte, time to encode.
-        if (buf[i - 1] !== 0) {
-          if ((buf[i - 1] & 0x80) !== 0) {
-            // We found a byte with it sign bit set so we need one more
-            // byte.
-            buf[i++] = last
-          } else {
-            // the sign bit is clear, we can use it.
-            buf[i - 1] |= last
-          }
-
-          return buf.slice(0, i)
-        }
-      }
-
-      // If we found the whole thing is zeros, then we have a zero.
-      return []
-    }
-
     const padDataToSize = (buf: number[], len: number): number[] => {
       let b = buf
       while (b.length < len) {

package/src/script/templates/P2PKH.ts

@@ -21,7 +21,7 @@ export default class P2PKH implements ScriptTemplate {
    * @param {number[] | string} pubkeyhash or address - An array or address representing the public key hash.
    * @returns {LockingScript} - A P2PKH locking script.
    */
-  lock (pubkeyhash: string | number[]): LockingScript {
+  lock(pubkeyhash: string | number[]): LockingScript {
     let data: number[]
     if (typeof pubkeyhash === 'string') {
       const hash = fromBase58Check(pubkeyhash)
@@ -54,16 +54,16 @@ export default class P2PKH implements ScriptTemplate {
    * @param {Script} lockingScript - Optional. The lockinScript. Otherwise the input.sourceTransaction is required.
    * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
    */
-  unlock (
+  unlock(
     privateKey: PrivateKey,
     signOutputs: 'all' | 'none' | 'single' = 'all',
     anyoneCanPay: boolean = false,
     sourceSatoshis?: number,
     lockingScript?: Script
   ): {
-      sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-      estimateLength: () => Promise<106>
-    } {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<108>
+  } {
     return {
       sign: async (tx: Transaction, inputIndex: number) => {
         let signatureScope = TransactionSignature.SIGHASH_FORKID
@@ -130,9 +130,9 @@ export default class P2PKH implements ScriptTemplate {
         ])
       },
       estimateLength: async () => {
-        // public key (1+33) + signature (1+71)
+        // public key (1+33) + signature (1+73)
         // Note: We add 1 to each element's length because of the associated OP_PUSH
-        return 106
+        return 108
       }
     }
   }

package/src/script/templates/RPuzzle.ts

@@ -23,7 +23,7 @@ export default class RPuzzle implements ScriptTemplate {
    *
    * @param {'raw'|'SHA1'|'SHA256'|'HASH256'|'RIPEMD160'|'HASH160'} type Denotes the type of puzzle to create
    */
-  constructor (type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw') {
+  constructor(type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw') {
     this.type = type
   }
 
@@ -33,7 +33,7 @@ export default class RPuzzle implements ScriptTemplate {
    * @param {number[]} value - An array representing the R value or its hash.
    * @returns {LockingScript} - An R puzzle locking script.
    */
-  lock (value: number[]): LockingScript {
+  lock(value: number[]): LockingScript {
     const chunks: ScriptChunk[] = [
       { op: OP.OP_OVER },
       { op: OP.OP_3 },
@@ -70,15 +70,15 @@ export default class RPuzzle implements ScriptTemplate {
    * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
    * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
    */
-  unlock (
+  unlock(
     k: BigNumber,
     privateKey: PrivateKey,
     signOutputs: 'all' | 'none' | 'single' = 'all',
     anyoneCanPay: boolean = false
   ): {
-      sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
-      estimateLength: () => Promise<106>
-    } {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<108>
+  } {
     return {
       sign: async (tx: Transaction, inputIndex: number) => {
         if (typeof privateKey === 'undefined') {
@@ -131,9 +131,9 @@ export default class RPuzzle implements ScriptTemplate {
         ])
       },
       estimateLength: async () => {
-        // public key (1+33) + signature (1+71)
+        // public key (1+33) + signature (1+73)
         // Note: We add 1 to each element's length because of the associated OP_PUSH
-        return 106
+        return 108
       }
     }
   }