mainnet-js 2.2.4 → 2.2.6

package/src/message/signed.test.ts

@@ -45,6 +45,18 @@ describe("Test message Signing and Verification", () => {
       "gE9BDBFAOqW+yoOzABjnM+LQRWHd4dvUVrsTR+sIWsU="
     );
     expect(result.details!.publicKeyHashMatch).toBe(true);
+    expect(result.details!.publicKeyMatch).toBe(false);
+    expect(result.details!.signatureValid).toBe(true);
+    expect(result.details!.signatureType).toBe("recoverable");
+
+    let msg2 = "Lessons for China from Japan’s lost decade";
+    result = await SignedMessage.verify(msg2, sig.signature, w1.cashaddr!);
+    expect(result.valid).toBe(false);
+    expect(result.details!.messageHash).toBe(
+      "070kQIcYPSHApGdOGH0O81N1AkMbNKwCTM3IX2Svd3I="
+    );
+    expect(result.details!.publicKeyHashMatch).toBe(false);
+    expect(result.details!.publicKeyMatch).toBe(false);
     expect(result.details!.signatureValid).toBe(true);
     expect(result.details!.signatureType).toBe("recoverable");
   });
@@ -64,6 +76,9 @@ describe("Test message Signing and Verification", () => {
     let sig = await SignedMessage.sign(msg, w.privateKey!);
     let result = await SignedMessage.verify(msg, sig.signature, w.cashaddr!);
     expect(result.valid).toBe(true);
+
+    result = await SignedMessage.verify("test2", sig.signature, w.cashaddr!);
+    expect(result.valid).toBe(false);
   });
 
   test("Test signing and verifying regtest signature using Alice's wallet", async () => {
@@ -75,6 +90,9 @@ describe("Test message Signing and Verification", () => {
 
     let result = await SignedMessage.verify(msg, sig.signature, w.cashaddr!);
     expect(result.valid).toBe(true);
+
+    result = await SignedMessage.verify("test2", sig.signature, w.cashaddr!);
+    expect(result.valid).toBe(false);
   });
 
   test("Test signing and verifying regtest signature using Alice's wallet", async () => {
@@ -85,6 +103,9 @@ describe("Test message Signing and Verification", () => {
     let sig = await SignedMessage.sign(msg, w.privateKey!);
     let result = await SignedMessage.verify(msg, sig.signature, w.cashaddr!);
     expect(result.valid).toBe(true);
+
+    result = await SignedMessage.verify("测试二", sig.signature, w.cashaddr!);
+    expect(result.valid).toBe(false);
   });
 
   test("Test signing and verifying a schnorr signature", async () => {
@@ -101,6 +122,16 @@ describe("Test message Signing and Verification", () => {
     );
     expect(result.valid).toBe(true);
     expect(result.details!.signatureType).toBe("schnorr");
+
+    let msg2 =
+      "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
+    let invalid = await SignedMessage.verify(
+      msg2,
+      sig.raw!.schnorr,
+      undefined,
+      w.publicKey!
+    );
+    expect(invalid.valid).toBe(false);
   });
 
   test("Test signing and verifying a der signature", async () => {
@@ -133,6 +164,16 @@ describe("Test message Signing and Verification", () => {
     );
     expect(result.valid).toBe(true);
     expect(result.details!.signatureType).toBe("ecdsa");
+
+    let msg2 =
+      "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
+    let invalid = await SignedMessage.verify(
+      msg2,
+      sig.raw!.ecdsa,
+      undefined,
+      w.publicKey!
+    );
+    expect(invalid.valid).toBe(false);
   });
 
   test("Test signing and verifying a long message", async () => {
@@ -160,10 +201,20 @@ describe("Test message Signing and Verification", () => {
       w1.cashaddr!
     );
     expect(result.valid).toBe(true);
+
+    let msg2 =
+      "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
+    let invalid = await Wallet.signedMessage.verify(
+      msg2,
+      sig.signature,
+      w1.cashaddr!
+    );
+    expect(invalid.valid).toBe(false);
   });
 
   test("Test electron cash example from a wallet instance", async () => {
     let msg1 = "Chancellor on brink of second bailout for banks";
+
     let w1 = await Wallet.fromId(
       `wif:mainnet:L1TnU2zbNaAqMoVh65Cyvmcjzbrj41Gs9iTLcWbpJCMynXuap6UN`
     );
@@ -173,5 +224,40 @@ describe("Test message Signing and Verification", () => {
     let sig = await w1.sign(msg1);
     let result = await w1.verify(msg1, sig.signature);
     expect(result.valid).toBe(true);
+
+    let msg2 =
+      "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
+    let invalid = await w1.verify(msg2, sig.signature);
+    expect(invalid.valid).toBe(false);
+  });
+
+  test("Test electron cash example from a wallet instance", async () => {
+    let beak = "Eeny meeny, hide & seek―catch a cephalopod by the beak";
+    let beakSig =
+      "H2a0aK6ZhF5rii4yzKkE+15yLTaQPa4KzoGXwYNHm5I+OYxRdcpTiUVZm3h6+ocy2JYxb0UUrQn7UWh8IcxzEtk=";
+
+    let falseMessage = "Employer provided healthcare is a benefit.";
+
+    let w1 = await Wallet.fromId(
+      `watch:mainnet:qqad5sy4jml3f6vcp246dulsex04xp48wq23d35rqe`
+    );
+    expect(w1.cashaddr!).toBe(
+      "bitcoincash:qqad5sy4jml3f6vcp246dulsex04xp48wq23d35rqe"
+    );
+    let result = await w1.verify(beak, beakSig);
+    expect(result.valid).toBe(true);
+    expect(result.details?.publicKeyHashMatch).toBe(true);
+    expect(result.details?.publicKeyMatch).toBe(false);
+    expect(result.details?.signatureValid).toBe(true);
+    expect(result.details?.signatureType).toBe("recoverable");
+
+    let badResult = await w1.verify(falseMessage, beakSig);
+    expect(badResult.valid).toBe(false);
+
+    // While the recoverable sig is valid, it doesn't match the message.
+    expect(badResult.details?.signatureValid).toBe(true);
+    expect(badResult.details?.publicKeyHashMatch).toBe(false);
+    expect(badResult.details?.publicKeyMatch).toBe(false);
+    expect(result.details?.signatureType).toBe("recoverable");
   });
 });

package/src/message/signed.ts

@@ -125,7 +125,8 @@ export class SignedMessage implements SignedMessageI {
     let messageHash = await hash_message(message);
     let sig = base64ToBin(signature);
 
-    let valid = false;
+    let signatureValid = false;
+    let keyMatch = false;
     let pkhMatch = false;
     let pkh, signatureType;
 
@@ -143,7 +144,7 @@ export class SignedMessage implements SignedMessageI {
 
       pkh = await hash160(recoveredPk);
       signatureType = "recoverable";
-      valid = secp256k1.verifySignatureCompact(
+      signatureValid = secp256k1.verifySignatureCompact(
         rawSig,
         recoveredPk,
         messageHash
@@ -163,29 +164,33 @@ export class SignedMessage implements SignedMessageI {
     } else if (publicKey) {
       if (secp256k1.verifySignatureDER(sig, publicKey, messageHash)) {
         signatureType = "der";
-        valid = true;
+        signatureValid = true;
+        keyMatch = true;
       } else if (
         secp256k1.verifySignatureSchnorr(sig, publicKey, messageHash)
       ) {
         signatureType = "schnorr";
-        valid = true;
+        signatureValid = true;
+        keyMatch = true;
       } else if (
         secp256k1.verifySignatureCompact(sig, publicKey, messageHash)
       ) {
         signatureType = "ecdsa";
-        valid = true;
+        signatureValid = true;
+        keyMatch = true;
       } else {
         signatureType = "na";
       }
     }
 
     return {
-      valid: valid,
+      valid: signatureValid && (keyMatch || pkhMatch),
       details: {
-        signatureValid: valid,
+        signatureValid: signatureValid,
         signatureType: signatureType,
         messageHash: binToBase64(messageHash),
         publicKeyHashMatch: pkhMatch,
+        publicKeyMatch: keyMatch,
       },
     };
   }

package/src/wallet/Wif.ts

@@ -1,13 +1,21 @@
 //#region Imports
 // Stable
-import { encodeHdPublicKey, HdKeyNetwork, secp256k1 } from "@bitauth/libauth";
+import {
+  decodeCashAddress,
+  decodeCashAddressVersionByte,
+  encodeHdPublicKey,
+  HdKeyNetwork,
+  secp256k1,
+} from "@bitauth/libauth";
 
 // Unstable?
 import {
   binToHex,
   CashAddressNetworkPrefix,
+  CashAddressType,
   deriveHdPublicNode,
   decodePrivateKeyWif,
+  encodeCashAddress,
   encodePrivateKeyWif,
   deriveHdPrivateNodeFromSeed,
   deriveHdPath,
@@ -497,10 +505,29 @@ export class Wallet extends BaseWallet {
       }
     }
 
-    this.cashaddr = `${addressPrefix}:${addressBase}`;
+    const prefixedAddress = `${addressPrefix}:${addressBase}`;
+
+    // check if a token aware address was provided
+    let addressData = decodeCashAddress(prefixedAddress);
+    if (typeof addressData === "string") throw addressData;
+
+    this.publicKeyHash = addressData.payload;
+
+    let nonTokenAwareType = addressData.type;
+    if (nonTokenAwareType == CashAddressType.p2pkhWithTokens)
+      nonTokenAwareType = CashAddressType.p2pkh;
+    if (nonTokenAwareType == CashAddressType.p2shWithTokens)
+      nonTokenAwareType = CashAddressType.p2sh;
+    if (nonTokenAwareType == CashAddressType.p2pkh)
+      this.publicKeyHash = addressData.payload;
+
+    this.cashaddr = encodeCashAddress(
+      addressData.prefix as CashAddressNetworkPrefix,
+      nonTokenAwareType,
+      addressData.payload
+    );
     this.address = this.cashaddr;
-    this.publicKeyHash = derivePublicKeyHash(this.cashaddr);
-    this.tokenaddr = deriveTokenaddr(this.publicKeyHash, this.networkPrefix);
+    this.tokenaddr = deriveTokenaddr(addressData.payload, this.networkPrefix);
 
     return this;
   }

package/src/wallet/Wif.watchOnly.test.ts

@@ -0,0 +1,58 @@
+import { RegTestWallet, TestNetWallet, Wallet } from "./Wif";
+import { initProviders, disconnectProviders } from "../network/Connection";
+
+beforeAll(async () => {
+  await initProviders();
+});
+afterAll(async () => {
+  await disconnectProviders();
+});
+
+describe(`Test creation of wallet from walletId`, () => {
+  test("Get a regtest wallet from string id", async () => {
+    const ADDRESS = "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0";
+    const ADDRESS_TOKEN = "bchreg:zpttdv3qg2usm4nm7talhxhl05mlhms3ysjm0q59vu";
+
+    let w = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+
+    expect(w.cashaddr!.startsWith("bchreg:")).toBeTruthy();
+    expect(w.address!).toBe(ADDRESS);
+    expect(w.cashaddr!).toBe(ADDRESS);
+    expect(w.tokenaddr!).toBe(ADDRESS_TOKEN);
+    let w2 = await RegTestWallet.watchOnly(w.cashaddr!);
+
+    expect(w2.address!).toBe(ADDRESS);
+    expect(w2.cashaddr!).toBe(ADDRESS);
+    expect(w2.tokenaddr!).toBe(ADDRESS_TOKEN);
+
+    let w3 = await RegTestWallet.watchOnly(ADDRESS_TOKEN);
+    expect(w3.address!).toBe(ADDRESS);
+    expect(w3.cashaddr!).toBe(ADDRESS);
+    expect(w3.tokenaddr!).toBe(ADDRESS_TOKEN);
+  });
+
+  test("Get create a p2sh32 watch address", async () => {
+    const ADDRESS =
+      "bitcoincash:pvykylj7uk385669fjse37r2eknx35ngaalx805q2hul62lmx2fq2v5dx6g8w";
+
+    let w = await Wallet.watchOnly(
+      "bitcoincash:pvykylj7uk385669fjse37r2eknx35ngaalx805q2hul62lmx2fq2v5dx6g8w"
+    );
+
+    expect(w.cashaddr!.startsWith("bitcoincash:")).toBeTruthy();
+    expect(w.address!).toBe(ADDRESS);
+  });
+
+  test("Get create a p2sh watch address", async () => {
+    const ADDRESS = "bitcoincash:pzvts0uztwg32yvrx7xz9lp572dgnt20sy0dj993vx";
+
+    let w = await Wallet.watchOnly(
+      "bitcoincash:pzvts0uztwg32yvrx7xz9lp572dgnt20sy0dj993vx"
+    );
+
+    expect(w.cashaddr!.startsWith("bitcoincash:")).toBeTruthy();
+    expect(w.address!).toBe(ADDRESS);
+  });
+});