Add signMessageHash method to SignatureTemplate

Author: rkalis

examples/PriceOracle.ts

@@ -1,8 +1,9 @@
-import { padMinimallyEncodedVmNumber, flattenBinArray, secp256k1 } from '@bitauth/libauth';
+import { padMinimallyEncodedVmNumber, flattenBinArray } from '@bitauth/libauth';
 import { encodeInt, sha256 } from '@cashscript/utils';
+import { SignatureAlgorithm, SignatureTemplate } from 'cashscript';
 
 export class PriceOracle {
-  constructor(public privateKey: Uint8Array) {}
+  constructor(public privateKey: Uint8Array) { }
 
   // Encode a blockHeight and bchUsdPrice into a byte sequence of 8 bytes (4 bytes per value)
   createMessage(blockHeight: bigint, bchUsdPrice: bigint): Uint8Array {
@@ -12,9 +13,8 @@ export class PriceOracle {
     return flattenBinArray([encodedBlockHeight, encodedBchUsdPrice]);
   }
 
-  signMessage(message: Uint8Array): Uint8Array {
-    const signature = secp256k1.signMessageHashSchnorr(this.privateKey, sha256(message));
-    if (typeof signature === 'string') throw new Error();
-    return signature;
+  signMessage(message: Uint8Array, signatureAlgorithm: SignatureAlgorithm = SignatureAlgorithm.SCHNORR): Uint8Array {
+    const signatureTemplate = new SignatureTemplate(this.privateKey, undefined, signatureAlgorithm);
+    return signatureTemplate.signMessageHash(sha256(message));
   }
 }

packages/cashscript/src/SignatureTemplate.ts

@@ -31,13 +31,17 @@ export default class SignatureTemplate {
     }
   }
 
-  // TODO: Allow signing of non-transaction messages (i.e. don't add the hashtype)
   generateSignature(payload: Uint8Array, bchForkId?: boolean): Uint8Array {
+    const signature = this.signMessageHash(payload);
+    return Uint8Array.from([...signature, this.getHashType(bchForkId)]);
+  }
+
+  signMessageHash(payload: Uint8Array): Uint8Array {
     const signature = this.signatureAlgorithm === SignatureAlgorithm.SCHNORR
       ? secp256k1.signMessageHashSchnorr(this.privateKey, payload) as Uint8Array
       : secp256k1.signMessageHashDER(this.privateKey, payload) as Uint8Array;
 
-    return Uint8Array.from([...signature, this.getHashType(bchForkId)]);
+    return signature;
   }
 
   getHashType(bchForkId: boolean = true): number {

packages/cashscript/test/SignatureTemplate.test.ts

@@ -46,6 +46,22 @@ describe('SignatureTemplate', () => {
     });
   });
 
+  describe('signMessageHash', () => {
+    it('should generate a correct signature using Schnorr', () => {
+      const signatureTemplate = new SignatureTemplate(alicePriv);
+      const signature = signatureTemplate.signMessageHash(hexToBin('0000000000000000000000'));
+      expect(signature).toEqual(hexToBin('bcac180e17de108003cce026708bd2af54b860dad2626cee157f4ed5abd993b9085d615015f905978adc51e8878226280ddd27d899f086519c0978e53332d799'));
+    });
+  });
+
+  describe('signMessageHash', () => {
+    it('should generate a correct signature using ECDSA', () => {
+      const signatureTemplate = new SignatureTemplate(alicePriv, undefined, SignatureAlgorithm.ECDSA);
+      const signature = signatureTemplate.signMessageHash(hexToBin('0000000000000000000000'));
+      expect(signature).toEqual(hexToBin('3045022100fa1d6a159a124e99479f78152422d55ff3c16f7fac5ae47fa291907f8f47613f02200d6c906f667b3712860b6f5a1f296ecb7dcd44da83c6a1eb45869b61c6b8dadb'));
+    });
+  });
+
   describe('getPublicKey', () => {
     it('should generate a correct public key', () => {
       const signatureTemplate = new SignatureTemplate(alicePriv);

packages/cashscript/test/fixture/PriceOracle.ts

@@ -1,9 +1,9 @@
-import { padMinimallyEncodedVmNumber, flattenBinArray, secp256k1 } from '@bitauth/libauth';
+import { padMinimallyEncodedVmNumber, flattenBinArray } from '@bitauth/libauth';
 import { encodeInt, sha256 } from '@cashscript/utils';
-import { SignatureAlgorithm } from '../../src/index.js';
+import { SignatureAlgorithm, SignatureTemplate } from '../../src/index.js';
 
 export class PriceOracle {
-  constructor(public privateKey: Uint8Array) {}
+  constructor(public privateKey: Uint8Array) { }
 
   // Encode a blockHeight and bchUsdPrice into a byte sequence of 8 bytes (4 bytes per value)
   createMessage(blockHeight: bigint, bchUsdPrice: bigint): Uint8Array {
@@ -14,11 +14,7 @@ export class PriceOracle {
   }
 
   signMessage(message: Uint8Array, signatureAlgorithm: SignatureAlgorithm = SignatureAlgorithm.SCHNORR): Uint8Array {
-    const signature = signatureAlgorithm === SignatureAlgorithm.SCHNORR ?
-      secp256k1.signMessageHashSchnorr(this.privateKey, sha256(message)) :
-      secp256k1.signMessageHashDER(this.privateKey, sha256(message));
-
-    if (typeof signature === 'string') throw new Error();
-    return signature;
+    const signatureTemplate = new SignatureTemplate(this.privateKey, undefined, signatureAlgorithm);
+    return signatureTemplate.signMessageHash(sha256(message));
   }
 }

website/docs/releases/release-notes.md

@@ -11,6 +11,7 @@ title: Release Notes
 - :boom: **BREAKING**: No longer seed the MockNetworkProvider with any test UTXOs.
 - :sparkles: Add a configurable `vmTarget` option to `MockNetworkProvider`.
 - :sparkles: Add support for ECDSA signatures in contract unlockers for `sig` and `datasig` parameters.
+- :sparkles: Add `signMessageHash()` method to `SignatureTemplate` to allow for signing of non-transaction messages.
 - :hammer_and_wrench: Improve libauth template generation.
 - :bug: Fix bug where `SignatureTemplate` would not accept private key hex strings as a signer.
 

website/docs/sdk/examples.md

@@ -92,11 +92,12 @@ console.log('contract balance:', await contract.getBalance());
 We need the create the functionality for generating and signing the oracle message to use in the HodlVault contract:
 
 ```ts title="PriceOracle.ts"
-import { padMinimallyEncodedVmNumber, flattenBinArray, secp256k1 } from '@bitauth/libauth';
+import { padMinimallyEncodedVmNumber, flattenBinArray } from '@bitauth/libauth';
 import { encodeInt, sha256 } from '@cashscript/utils';
+import { SignatureAlgorithm, SignatureTemplate } from 'cashscript';
 
 export class PriceOracle {
-  constructor(public privateKey: Uint8Array) {}
+  constructor(public privateKey: Uint8Array) { }
 
   // Encode a blockHeight and bchUsdPrice into a byte sequence of 8 bytes (4 bytes per value)
   createMessage(blockHeight: bigint, bchUsdPrice: bigint): Uint8Array {
@@ -106,12 +107,12 @@ export class PriceOracle {
     return flattenBinArray([encodedBlockHeight, encodedBchUsdPrice]);
   }
 
-  signMessage(message: Uint8Array): Uint8Array {
-    const signature = secp256k1.signMessageHashSchnorr(this.privateKey, sha256(message));
-    if (typeof signature === 'string') throw new Error();
-    return signature;
+  signMessage(message: Uint8Array, signatureAlgorithm: SignatureAlgorithm = SignatureAlgorithm.SCHNORR): Uint8Array {
+    const signatureTemplate = new SignatureTemplate(this.privateKey, undefined, signatureAlgorithm);
+    return signatureTemplate.signMessageHash(sha256(message));
   }
 }
+
 ```
 
 ### Sending a Transaction

website/docs/sdk/signature-templates.md

@@ -2,7 +2,7 @@
 title: Signature Templates
 ---
 
-When a contract function has a `sig` parameter, it needs a cryptographic signature from a private key for the spending transaction. 
+When a contract function has a `sig` parameter, it needs a cryptographic signature from a private key for the spending transaction.
 In place of a signature, a `SignatureTemplate` can be passed, which will generate the correct signature when the transaction is built.
 
 :::tip
@@ -59,7 +59,7 @@ transactionBuilder.addInput(aliceUtxos[0], aliceTemplate.unlockP2PKH());
 
 ### getPublicKey()
 
-The `SignatureTemplate` also had a helper method to get the matching PublicKey in the following way:
+The `SignatureTemplate` also has a helper method to get the matching PublicKey in the following way:
 
 ```ts
 signatureTemplate.getPublicKey(): Uint8Array
@@ -72,6 +72,23 @@ import { aliceTemplate } from './somewhere.js';
 const alicePublicKey = aliceTemplate.getPublicKey()
 ```
 
+### signMessageHash()
+
+The `SignatureTemplate` also has a helper method to sign a message hash, which can be used to sign non-transaction messages. This is useful for generating `datasig` signatures for smart contract use cases.
+
+```ts
+signatureTemplate.signMessageHash(message: Uint8Array): Uint8Array
+```
+
+#### Example
+```ts
+import { aliceTemplate } from './somewhere.js';
+import { sha256 } from '@cashscript/utils';
+import { hexToBin } from '@bitauth/libauth';
+
+const signature = aliceTemplate.signMessageHash(sha256(hexToBin('0000000000000000000000')));
+```
+
 ## Advanced Usage
 
 ### HashType