mainnet-js 1.1.19 → 1.1.21

package/src/network/default.ts

@@ -12,8 +12,7 @@ import { Network } from "../interface.js";
 import {
   networkTickerMap,
   clusterParams,
-  ELECTRUM_CASH_PROTOCOL_VERSION,
-  ELECTRUM_CASH_PROTOCOL_VERSION_MAINNET,
+  ELECTRUM_CASH_PROTOCOL_VERSION
 } from "./constant.js";
 
 export function setGlobalProvider(
@@ -129,9 +128,7 @@ function getClient(servers: string[], network: Network) {
 function getElectrumCluster(params: ElectrumClusterParams, network: Network) {
   return new ElectrumCluster(
     getUserAgent(),
-    network === Network.MAINNET
-      ? ELECTRUM_CASH_PROTOCOL_VERSION_MAINNET
-      : ELECTRUM_CASH_PROTOCOL_VERSION,
+    ELECTRUM_CASH_PROTOCOL_VERSION,
     params.confidence,
     params.distribution,
     params.order,
@@ -146,9 +143,7 @@ function getElectrumClient(
 ) {
   return new ElectrumClient(
     getUserAgent(),
-    network === Network.MAINNET
-      ? ELECTRUM_CASH_PROTOCOL_VERSION_MAINNET
-      : ELECTRUM_CASH_PROTOCOL_VERSION,
+    ELECTRUM_CASH_PROTOCOL_VERSION,
     params.host,
     params.port,
     params.scheme,

package/src/wallet/Bcmr.test.headless.js

@@ -179,8 +179,8 @@ describe(`Wallet should function in the browser`, () => {
         });
         expect(chain.length).toBe(1);
         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/.well-known/bitcoin-cash-metadata-registry.json"
         );
 
         const tokenInfo = BCMR.getTokenInfo(
@@ -345,22 +345,34 @@ describe(`Wallet should function in the browser`, () => {
         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"
         );
 
@@ -380,4 +392,76 @@ describe(`Wallet should function in the browser`, () => {
       [process.env.ALICE_ID, registry]
     );
   });
+
+  test("Auth chain: BCMR, ipfs hash", async () => {
+    await page.evaluate(
+      async ([id, registry]) => {
+        const alice = await RegTestWallet.fromId(id);
+        const bob = await RegTestWallet.newRandom();
+
+        const chunks = [
+          "BCMR",
+          "QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv",
+        ];
+        const opreturnData = OpReturnData.fromArray(chunks);
+
+        const response = await alice.send([
+          new SendRequest({ cashaddr: bob.cashaddr, value: 1000, unit: "sat" }),
+          opreturnData,
+        ]);
+        const chain = await BCMR.buildAuthChain({
+          transactionHash: response.txId,
+          network: Network.REGTEST,
+        });
+        expect(chain.length).toBe(1);
+        expect(chain[0].contentHash).toBe(
+          "516d62577247354173703569476d557751486f67534a47525832367a75526e754c575079745a66694c3735735a76"
+        );
+        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);
+      },
+      [process.env.ALICE_ID, registry]
+    );
+  });
+
+  test("Auth chain: BCMR, sha256 content hash, 2 uris", async () => {
+    await page.evaluate(
+      async ([id, registry]) => {
+        const alice = await RegTestWallet.fromId(id);
+        const bob = await RegTestWallet.newRandom();
+
+        const chunks = [
+          "BCMR",
+          sha256.hash(utf8ToBin("registry_contents")),
+          "mainnet.cash",
+          "ipfs://QmbWrG5Asp5iGmUwQHogSJGRX26zuRnuLWPytZfiL75sZv",
+        ];
+        const opreturnData = OpReturnData.fromArray(chunks);
+        const response = await alice.send([
+          new SendRequest({ cashaddr: bob.cashaddr, value: 1000, unit: "sat" }),
+          opreturnData,
+        ]);
+        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"
+        );
+      },
+      [process.env.ALICE_ID, registry]
+    );
+  });
 });

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);
@@ -244,11 +247,7 @@ describe(`Test BCMR support`, () => {
     const bob = await RegTestWallet.newRandom();
 
     const contentHashBin = sha256.hash(utf8ToBin("registry_contents"));
-    const chunks = [
-      "BCMR",
-      contentHashBin,
-      "mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json",
-    ];
+    const chunks = ["BCMR", contentHashBin, "mainnet.cash"];
     const opreturnData = OpReturnData.fromArray(chunks);
 
     const response = await alice.send([
@@ -261,13 +260,14 @@ 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 +276,28 @@ 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 +354,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 +403,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,17 +441,24 @@ describe(`Test BCMR support`, () => {
 
       expect(chain.length).toBe(3);
       expect(chain[0].txHash).toBe(response.txId!);
-      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[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"
       );
 
@@ -453,7 +471,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 +486,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 +637,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 +718,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 +757,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 +794,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);