mainnet-js 1.1.18 → 1.1.20

package/src/wallet/Bcmr.test.ts

@@ -231,7 +231,10 @@ describe(`Test BCMR support`, () => {
     expect(chain[0].contentHash).toBe(
       "516d62577247354173703569476d557751486f67534a47525832367a75526e754c575079745a66694c3735735a76"
     );
-    expect(chain[0].uri).toBe(
+    expect(chain[0].uris[0]).toBe(
+      "ipfs://QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv"
+    );
+    expect(chain[0].httpsUrl).toBe(
       "https://dweb.link/ipfs/QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv"
     );
     expect(chain[0].txHash).toBe(response.txId);
@@ -247,7 +250,7 @@ describe(`Test BCMR support`, () => {
     const chunks = [
       "BCMR",
       contentHashBin,
-      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json",
+      "mainnet.cash",
     ];
     const opreturnData = OpReturnData.fromArray(chunks);
 
@@ -261,13 +264,16 @@ describe(`Test BCMR support`, () => {
     });
     expect(chain.length).toBe(1);
     expect(chain[0].contentHash).toBe(binToHex(contentHashBin));
-    expect(chain[0].uri).toBe(
+    expect(chain[0].uris[0]).toBe(
+      "mainnet.cash"
+    );
+    expect(chain[0].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
     );
     expect(chain[0].txHash).toBe(response.txId);
   });
 
-  test("Auth chain: BCMR, sha256 content hash, uri and another chunk", async () => {
+  test("Auth chain: BCMR, sha256 content hash, 2 uris", async () => {
     const alice = await RegTestWallet.fromId(
       `wif:regtest:${process.env.PRIVATE_WIF!}`
     );
@@ -276,20 +282,24 @@ describe(`Test BCMR support`, () => {
     const chunks = [
       "BCMR",
       sha256.hash(utf8ToBin("registry_contents")),
-      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json",
-      "something else",
+      "mainnet.cash",
+      "ipfs://QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv",
     ];
     const opreturnData = OpReturnData.fromArray(chunks);
     const response = await alice.send([
       new SendRequest({ cashaddr: bob.cashaddr!, value: 1000, unit: "sat" }),
       opreturnData,
     ]);
-    await expect(
-      BCMR.buildAuthChain({
-        transactionHash: response.txId!,
-        network: Network.REGTEST,
-      })
-    ).rejects.toThrow("Malformed BCMR output");
+    const chain = await BCMR.buildAuthChain({
+      transactionHash: response.txId!,
+      network: Network.REGTEST,
+    });
+
+    expect(chain.length).toBe(1);
+    expect(chain[0].uris.length).toBe(2);
+    expect(chain[0].uris[0]).toBe("mainnet.cash");
+    expect(chain[0].uris[1]).toBe("ipfs://QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv");
+    expect(chain[0].httpsUrl).toBe("https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json");
   });
 
   test("Auth chain: all OP_PUSDHDATA encodings", async () => {
@@ -346,7 +356,10 @@ describe(`Test BCMR support`, () => {
     });
     expect(chain.length).toBe(1);
     expect(chain[0].txHash).toBe(response.txId!);
-    expect(chain[0].uri).toBe(
+    expect(chain[0].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+    );
+    expect(chain[0].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
     );
 
@@ -392,7 +405,7 @@ describe(`Test BCMR support`, () => {
       let chunks = [
         "BCMR",
         registryContentHashBinBitcoinByteOrder,
-        "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json",
+        "mainnet.cash",
       ];
       const opreturnData = OpReturnData.fromArray(chunks);
       const response = await alice.send([
@@ -430,19 +443,23 @@ describe(`Test BCMR support`, () => {
 
       expect(chain.length).toBe(3);
       expect(chain[0].txHash).toBe(response.txId!);
-      expect(chain[0].uri).toBe(
-        "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+      expect(chain[0].uris[0]).toBe(
+        "mainnet.cash"
       );
+      expect(chain[0].httpsUrl).toBe("https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json");
 
       expect(chain[1].txHash).toBe(response2.txId!);
-      expect(chain[1].uri).toBe(
-        "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
+      expect(chain[1].uris[0]).toBe(
+        "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
       );
+      expect(chain[1].httpsUrl).toBe("https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json");
+
 
       expect(chain[2].txHash).toBe(response3.txId!);
-      expect(chain[2].uri).toBe(
-        "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
+      expect(chain[2].uris[0]).toBe(
+        "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
       );
+      expect(chain[2].httpsUrl).toBe("https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json");
 
       // extra checks for resolving chains not from head
       if (index === 0) {
@@ -453,7 +470,10 @@ describe(`Test BCMR support`, () => {
         });
         expect(noFollow.length).toBe(1);
         expect(noFollow[0].txHash).toBe(response2.txId!);
-        expect(noFollow[0].uri).toBe(
+        expect(noFollow[0].uris[0]).toBe(
+          "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
+        );
+        expect(noFollow[0].httpsUrl).toBe(
           "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
         );
 
@@ -465,12 +485,18 @@ describe(`Test BCMR support`, () => {
         expect(follow.length).toBe(2);
 
         expect(follow[0].txHash).toBe(response2.txId!);
-        expect(follow[0].uri).toBe(
+        expect(follow[0].uris[0]).toBe(
+          "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
+        );
+        expect(follow[0].httpsUrl).toBe(
           "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
         );
 
         expect(follow[1].txHash).toBe(response3.txId!);
-        expect(follow[1].uri).toBe(
+        expect(follow[1].uris[0]).toBe(
+          "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
+        );
+        expect(follow[1].httpsUrl).toBe(
           "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
         );
       }
@@ -610,22 +636,34 @@ describe(`Test BCMR support`, () => {
     expect(chain.length).toBe(4);
 
     expect(chain[0].txHash).toBe(response.txId!);
-    expect(chain[0].uri).toBe(
+    expect(chain[0].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v1.json"
+    );
+    expect(chain[0].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v1.json"
     );
 
     expect(chain[1].txHash).toBe(response2.txId!);
-    expect(chain[1].uri).toBe(
+    expect(chain[1].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
+    );
+    expect(chain[1].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
     );
 
     expect(chain[2].txHash).toBe(response3.txId!);
-    expect(chain[2].uri).toBe(
+    expect(chain[2].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
+    );
+    expect(chain[2].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
     );
 
     expect(chain[3].txHash).toBe(response4.txId!);
-    expect(chain[3].uri).toBe(
+    expect(chain[3].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v4.json"
+    );
+    expect(chain[3].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v4.json"
     );
 
@@ -679,7 +717,10 @@ describe(`Test BCMR support`, () => {
     expect(chain[0].contentHash).toBe(
       "516d62577247354173703569476d557751486f67534a47525832367a75526e754c575079745a66694c3735735a76"
     );
-    expect(chain[0].uri).toBe(
+    expect(chain[0].uris[0]).toBe(
+      "ipfs://QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv"
+    );
+    expect(chain[0].httpsUrl).toBe(
       "https://dweb.link/ipfs/QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv"
     );
     expect(chain[0].txHash).toBe(genesisResponse.txId);
@@ -715,7 +756,10 @@ describe(`Test BCMR support`, () => {
     });
     expect(chain.length).toBe(1);
     expect(chain[0].contentHash).toBe(binToHex(contentHashBin));
-    expect(chain[0].uri).toBe(
+    expect(chain[0].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+    );
+    expect(chain[0].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
     );
     expect(chain[0].txHash).toBe(response.txId);
@@ -749,13 +793,19 @@ describe(`Test BCMR support`, () => {
     });
     expect(gappedChain.length).toBe(2);
     expect(gappedChain[0].contentHash).toBe(binToHex(contentHashBin));
-    expect(gappedChain[0].uri).toBe(
+    expect(gappedChain[0].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+    );
+    expect(gappedChain[0].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
     );
     expect(gappedChain[0].txHash).toBe(response.txId);
 
     expect(gappedChain[1].contentHash).toBe(binToHex(contentHashBin));
-    expect(gappedChain[1].uri).toBe(
+    expect(gappedChain[1].uris[0]).toBe(
+      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+    );
+    expect(gappedChain[1].httpsUrl).toBe(
       "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
     );
     expect(gappedChain[1].txHash).toBe(chainHeadResponse.txId);

package/src/wallet/Bcmr.ts

@@ -14,11 +14,13 @@ import ElectrumNetworkProvider from "../network/ElectrumNetworkProvider.js";
 import { ElectrumRawTransaction } from "../network/interface.js";
 import { IdentitySnapshot, Registry } from "./bcmr-v2.schema.js";
 import { initProvider } from "../network/Connection.js";
+import { OpReturnData } from "./model.js";
 
 export interface AuthChainElement {
   txHash: string;
   contentHash: string;
-  uri: string;
+  uris: string[];
+  httpsUrl: string;
 }
 
 export type AuthChain = AuthChainElement[];
@@ -236,58 +238,62 @@ export class BCMR {
         return {
           txHash: hash,
           contentHash: "",
-          uri: "",
+          uris: [],
+          httpsUrl: "",
         };
       }
 
       const opReturnHex = opReturns[0];
-      const opReturn = hexToBin(opReturnHex);
-      const chunks: Uint8Array[] = [];
-      let position = 1;
-
-      // handle direct push, OP_PUSHDATA1, OP_PUSHDATA2;
-      // OP_PUSHDATA4 is not supported in OP_RETURNs by consensus
-      while (opReturn[position]) {
-        let length = 0;
-        if (opReturn[position] === 0x4c) {
-          length = opReturn[position + 1];
-          position += 2;
-        } else if (opReturn[position] === 0x4d) {
-          length = binToNumberUint16LE(
-            opReturn.slice(position + 1, position + 3)
-          );
-          position += 3;
-        } else {
-          length = opReturn[position];
-          position += 1;
-        }
-
-        chunks.push(opReturn.slice(position, position + length));
-        position += length;
-      }
-
-      if (chunks.length < 2 || chunks.length > 3) {
+      const chunks = OpReturnData.parseBinary(hexToBin(opReturnHex));
+      if (chunks.length < 2) {
         throw new Error(`Malformed BCMR output: ${opReturnHex}`);
       }
 
       const result: AuthChainElement = {
         txHash: hash,
         contentHash: "",
-        uri: "",
+        uris: [],
+        httpsUrl: "",
       };
 
       if (chunks.length === 2) {
         // IPFS Publication Output
         result.contentHash = binToHex(chunks[1]);
         const ipfsCid = binToUtf8(chunks[1]);
-        result.uri = `https://dweb.link/ipfs/${ipfsCid}`;
+        result.uris = [`ipfs://${ipfsCid}`];
+        result.httpsUrl = `https://dweb.link/ipfs/${ipfsCid}`;
       } else {
-        // HTTPS Publication Output
+        // URI Publication Output
         // content hash is in OP_SHA256 byte order per spec
         result.contentHash = binToHex(chunks[1].slice());
-        result.uri = binToUtf8(chunks[2]);
-        if (result.uri.indexOf("https://") < 0) {
-          result.uri = `https://${result.uri}`;
+
+        const uris = chunks.slice(2);
+
+        for (const uri of uris) {
+          const uriString = binToUtf8(uri);
+          result.uris.push(uriString);
+
+          if (result.httpsUrl) {
+            continue;
+          }
+
+          if (uriString.indexOf("https://") === 0) {
+            result.httpsUrl = uriString;
+          } else if (uriString.indexOf("https://") === -1) {
+            result.httpsUrl = uriString;
+
+            // case for domain name specifier, like example.com
+            if (uriString.indexOf("/") === -1) {
+              result.httpsUrl = `${result.httpsUrl}/.well-known/bitcoin-cash-metadata-registry.json`
+            }
+
+            result.httpsUrl = `https://${result.httpsUrl}`;
+          } else if (uriString.indexOf("ipfs://") === 0 ) {
+            const ipfsCid = uriString.replace("ipfs://", "");
+            result.httpsUrl = `https://dweb.link/ipfs/${ipfsCid}`
+          } else {
+            throw new Error(`Unsupported uri type: ${uriString}`)
+          }
         }
       }
       return result;
@@ -317,7 +323,7 @@ export class BCMR {
     if (options.resolveBase) {
       // check for accelerated path if "authchain" extension is in registry
       const registry: Registry = await this.fetchMetadataRegistry(
-        element.uri,
+        element.httpsUrl,
         element.contentHash
       );
       if (
@@ -379,13 +385,13 @@ export class BCMR {
 
         // combine the authchain element with the rest obtained
         return [...chainBase, element, ...chainHead].filter(
-          (val) => val.uri.length
+          (val) => val.httpsUrl.length
         );
       }
     }
 
     // return the last chain element (or the only found in an edge case)
-    return [...chainBase, element].filter((val) => val.uri.length);
+    return [...chainBase, element].filter((val) => val.httpsUrl.length);
   }
 
   /**
@@ -420,7 +426,7 @@ export class BCMR {
     }
 
     const registry = await this.fetchMetadataRegistry(
-      authChain.reverse()[0].uri
+      authChain.reverse()[0].httpsUrl
     );
 
     this.addMetadataRegistry(registry);