mainnet-js 0.5.9 → 1.0.0-rc.3

package/src/util/sumUtxoValue.ts

@@ -1,15 +1,27 @@
-import { UtxoI } from "../interface";
+import { UtxoI } from "../interface.js";
 
-export async function sumUtxoValue(utxos: UtxoI[]) {
+export function sumUtxoValue(utxos: UtxoI[]) {
   if (utxos.length > 0) {
-    const balanceArray: number[] = await Promise.all(
-      utxos.map(async (o: UtxoI) => {
-        return o.satoshis;
-      })
-    );
+    const balanceArray: number[] = utxos.map((o: UtxoI) => {
+      return o.satoshis;
+    });
     const balance = balanceArray.reduce((a: number, b: number) => a + b, 0);
     return balance;
   } else {
     return 0;
   }
 }
+
+export function sumTokenAmounts(utxos: UtxoI[], tokenId: string): number {
+  if (utxos.length > 0) {
+    const tokenArray: number[] = utxos
+      .filter((utxo) => utxo.token?.tokenId === tokenId)
+      .map((o: UtxoI) => {
+        return o.token?.amount || 0;
+      });
+    const balance = tokenArray.reduce((a: number, b: number) => a + b, 0);
+    return balance;
+  } else {
+    return 0;
+  }
+}

package/src/util/transaction.ts

@@ -0,0 +1,10 @@
+import { hexToBin, sha256, binToHex } from "@bitauth/libauth";
+
+export async function getTransactionHash(
+  rawTransactionHex: string
+): Promise<string> {
+  const transactionBin = hexToBin(rawTransactionHex);
+
+  // transaction hash is a double sha256 of a raw transaction data, reversed byte order
+  return binToHex(sha256.hash(sha256.hash(transactionBin)).reverse());
+}

package/src/wallet/Base.ts

@@ -1,11 +1,11 @@
-import { getStorageProvider } from "../db/util";
-import { MnemonicI, WalletI } from "./interface";
-import { NetworkType } from "../enum";
-import { StorageProvider } from "../db";
-import { getRuntimePlatform } from "../util/getRuntimePlatform";
-import { qrAddress } from "../qr/Qr";
-import { ImageI } from "../qr/interface";
-import { WalletTypeEnum } from "./enum";
+import { getStorageProvider } from "../db/getStorageProvider.js";
+import { MnemonicI, WalletI } from "./interface.js";
+import { NetworkType } from "../enum.js";
+import { StorageProvider } from "../db/index.js";
+import { getRuntimePlatform } from "../util/getRuntimePlatform.js";
+import { qrAddress } from "../qr/Qr.js";
+import { ImageI } from "../qr/interface.js";
+import { WalletTypeEnum } from "./enum.js";
 
 /**
  * A class to hold features used by all wallets
@@ -54,7 +54,7 @@ export class BaseWallet implements WalletI {
    *
    * @see {@link https://rest-unstable.mainnet.cash/api-docs/#/wallet/depositQr|/wallet/deposit_qr} for REST endpoint
    *
-   * @returns The qrcode for the slp address
+   * @returns The qrcode for the address
    */
   public getDepositQr(): ImageI {
     return qrAddress(this.getDepositAddress() as string);
@@ -85,7 +85,7 @@ export class BaseWallet implements WalletI {
    * @throws {Error} if called on BaseWallet
    */
   constructor(
-    name = "",
+    name: string = "",
     network = NetworkType.Mainnet,
     walletType = WalletTypeEnum.Seed
   ) {
@@ -153,7 +153,7 @@ export class BaseWallet implements WalletI {
    * such kind of wallet does not have a private key and is unable to spend any funds
    * however it still allows to use many utility functions such as getting and watching balance, etc.
    *
-   * @param address   cashaddress or slpaddress of a wallet
+   * @param address   cashaddress, token aware cashaddress or slpaddress of a wallet
    *
    * @returns instantiated wallet
    */

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

@@ -0,0 +1,353 @@
+const playwright = require("playwright");
+const PAGE_URL = "http://localhost:8080";
+
+describe(`Wallet should function in the browser`, () => {
+  let browser;
+  let page;
+
+  const registry = {
+    version: { major: 1, minor: 0, patch: 0 },
+    latestRevision: Date.toString(),
+    registryIdentity: {
+      name: "Test token registry",
+      time: { begin: Date.now() },
+      token: {
+        category:
+          "0000000000000000000000000000000000000000000000000000000000000000",
+        symbol: "TOK",
+        decimals: 8,
+      },
+    },
+  };
+
+  /**
+   * Create the browser and page context
+   */
+  beforeAll(async () => {
+    browser = await playwright["chromium"].launch();
+    page = await browser.newPage();
+
+    if (!page) {
+      throw new Error("Connection wasn't established");
+    }
+
+    // Open the page
+    await page.goto(PAGE_URL, {
+      waitUntil: "networkidle0",
+    });
+  });
+
+  afterAll(async () => {
+    await browser.close();
+  });
+
+  test("Add metadata registry and get token info", async () => {
+    await page.evaluate(
+      async ([id, registry]) => {
+        expect(
+          BCMR.getTokenInfo(
+            "0000000000000000000000000000000000000000000000000000000000000000"
+          )
+        ).toBe(undefined);
+        BCMR.addMetadataRegistry(registry);
+        const tokenInfo = BCMR.getTokenInfo(
+          "0000000000000000000000000000000000000000000000000000000000000000"
+        );
+        expect(tokenInfo?.token?.symbol).toBe("TOK");
+        expect(tokenInfo?.token?.decimals).toBe(8);
+
+        // check adding the same registry does not produce a duplicate
+        expect(BCMR.metadataRegistries.length).toBe(1);
+        BCMR.addMetadataRegistry(registry);
+        expect(BCMR.metadataRegistries.length).toBe(1);
+      },
+      [process.env.ALICE_ID, registry]
+    );
+  });
+
+  test(`Add metadata from uri and get token info`, async () => {
+    await page.evaluate(
+      async ([id, registry]) => {
+        BCMR.resetRegistries();
+
+        setupAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json",
+          registry
+        );
+
+        expect(
+          BCMR.getTokenInfo(
+            "0000000000000000000000000000000000000000000000000000000000000000"
+          )
+        ).toBe(undefined);
+        await BCMR.addMetadataRegistryFromUri(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+        );
+        const tokenInfo = BCMR.getTokenInfo(
+          "0000000000000000000000000000000000000000000000000000000000000000"
+        );
+        expect(tokenInfo?.token?.symbol).toBe("TOK");
+        expect(tokenInfo?.token?.decimals).toBe(8);
+
+        // check adding the same registry does not produce a duplicate
+        expect(BCMR.metadataRegistries.length).toBe(1);
+        await BCMR.addMetadataRegistryFromUri(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+        );
+        expect(BCMR.metadataRegistries.length).toBe(1);
+
+        removeAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+        );
+      },
+      [process.env.ALICE_ID, registry]
+    );
+  });
+
+  test("Auth chain with 1 element, add resolved registry", async () => {
+    await page.evaluate(
+      async ([id, registry]) => {
+        BCMR.resetRegistries();
+
+        const alice = await RegTestWallet.fromId(id);
+        const bob = await RegTestWallet.newRandom();
+
+        const registryContent = JSON.stringify(registry, null, 2);
+        const registryContentHashBin = sha256.hash(utf8ToBin(registryContent));
+        const registryContentHashBinBitcoinByteOrder = registryContentHashBin
+          .slice()
+          .reverse();
+
+        let chunks = [
+          "BCMR",
+          registryContentHashBinBitcoinByteOrder,
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json",
+        ];
+        const opreturnData = OpReturnData.fromArray(chunks);
+        const response = await alice.send([
+          new SendRequest({
+            cashaddr: bob.cashaddr,
+            value: 10000,
+            unit: "sat",
+          }),
+          opreturnData,
+        ]);
+
+        setupAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json",
+          registry
+        );
+
+        expect(
+          BCMR.getTokenInfo(
+            "0000000000000000000000000000000000000000000000000000000000000000"
+          )
+        ).toBe(undefined);
+        const chain = await BCMR.addMetadataRegistryAuthChain({
+          transactionHash: response.txId,
+          network: Network.REGTEST,
+        });
+        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"
+        );
+
+        const tokenInfo = BCMR.getTokenInfo(
+          "0000000000000000000000000000000000000000000000000000000000000000"
+        );
+        expect(tokenInfo?.token?.symbol).toBe("TOK");
+        expect(tokenInfo?.token?.decimals).toBe(8);
+
+        // check adding the same registry does not produce a duplicate
+        expect(BCMR.metadataRegistries.length).toBe(1);
+        const otherChain = await BCMR.addMetadataRegistryAuthChain({
+          transactionHash: response.txId,
+          network: Network.REGTEST,
+        });
+        expect(otherChain.length).toBe(1);
+        expect(BCMR.metadataRegistries.length).toBe(1);
+
+        removeAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry.json"
+        );
+      },
+      [process.env.ALICE_ID, registry]
+    );
+  });
+
+  test("Authchain tail resolution info in registry acceleration path", async () => {
+    await page.evaluate(
+      async ([id, registry]) => {
+        BCMR.resetRegistries();
+
+        const alice = await RegTestWallet.fromId(id);
+        const bob = await RegTestWallet.newRandom();
+
+        const registry_v1 = { ...registry };
+        registry_v1.extensions = { authchain: [] };
+        const contentHash_v1 = sha256
+          .hash(utf8ToBin(JSON.stringify(registry_v1, null, 2)))
+          .reverse();
+        setupAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v1.json",
+          JSON.stringify(registry_v1, null, 2)
+        );
+        let chunks = [
+          "BCMR",
+          contentHash_v1,
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v1.json",
+        ];
+        const opreturnData = OpReturnData.fromArray(chunks);
+        const response = await alice.send([
+          new SendRequest({
+            cashaddr: bob.cashaddr,
+            value: 10000,
+            unit: "sat",
+          }),
+          opreturnData,
+        ]);
+
+        const registry_v2 = { ...registry };
+        registry_v2.extensions = {
+          authchain: [await bob.provider.getRawTransaction(response.txId)],
+        };
+        const contentHash_v2 = sha256
+          .hash(utf8ToBin(JSON.stringify(registry_v2, null, 2)))
+          .reverse();
+        setupAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json",
+          JSON.stringify(registry_v2, null, 2)
+        );
+        chunks = [
+          "BCMR",
+          contentHash_v2,
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json",
+        ];
+        const opreturnData2 = OpReturnData.fromArray(chunks);
+        const response2 = await bob.send([
+          new SendRequest({ cashaddr: bob.cashaddr, value: 9500, unit: "sat" }),
+          opreturnData2,
+        ]);
+
+        const registry_v3 = { ...registry };
+        registry_v3.extensions = {
+          authchain: [
+            await bob.provider.getRawTransaction(response.txId),
+            await bob.provider.getRawTransaction(response2.txId),
+          ],
+        };
+        const contentHash_v3 = sha256
+          .hash(utf8ToBin(JSON.stringify(registry_v3, null, 2)))
+          .reverse();
+        setupAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json",
+          JSON.stringify(registry_v3, null, 2)
+        );
+        chunks = [
+          "BCMR",
+          contentHash_v3,
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json",
+        ];
+        const opreturnData3 = OpReturnData.fromArray(chunks);
+        const response3 = await bob.send([
+          new SendRequest({ cashaddr: bob.cashaddr, value: 9000, unit: "sat" }),
+          opreturnData3,
+        ]);
+
+        const registry_v4 = { ...registry };
+        registry_v4.extensions = {};
+        const contentHash_v4 = sha256
+          .hash(utf8ToBin(JSON.stringify(registry_v4, null, 2)))
+          .reverse();
+        setupAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v4.json",
+          JSON.stringify(registry_v4, null, 2)
+        );
+        chunks = [
+          "BCMR",
+          contentHash_v4,
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v4.json",
+        ];
+        const opreturnData4 = OpReturnData.fromArray(chunks);
+        const response4 = await bob.send([
+          new SendRequest({ cashaddr: bob.cashaddr, value: 8500, unit: "sat" }),
+          opreturnData4,
+        ]);
+
+        let chain = await BCMR.buildAuthChain({
+          transactionHash: response.txId,
+          network: Network.REGTEST,
+        });
+        expect(chain.length).toBe(4);
+
+        chain = await BCMR.buildAuthChain({
+          transactionHash: response.txId,
+          network: Network.REGTEST,
+          followToHead: false,
+        });
+        expect(chain.length).toBe(1);
+
+        // tail acceleration available, do not follow head
+        chain = await BCMR.buildAuthChain({
+          transactionHash: response3.txId,
+          network: Network.REGTEST,
+          followToHead: false,
+          resolveBase: true,
+        });
+        expect(chain.length).toBe(3);
+
+        // resolve single element
+        chain = await BCMR.buildAuthChain({
+          transactionHash: response3.txId,
+          network: Network.REGTEST,
+          followToHead: false,
+          resolveBase: false,
+        });
+        expect(chain.length).toBe(1);
+
+        // no acceleration available, will scan network
+        chain = await BCMR.buildAuthChain({
+          transactionHash: response4.txId,
+          network: Network.REGTEST,
+          resolveBase: true,
+        });
+        expect(chain.length).toBe(4);
+
+        expect(chain[0].txHash).toBe(response.txId);
+        expect(chain[0].uri).toBe(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v1.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[2].txHash).toBe(response3.txId);
+        expect(chain[2].uri).toBe(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
+        );
+
+        expect(chain[3].txHash).toBe(response4.txId);
+        expect(chain[3].uri).toBe(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v4.json"
+        );
+
+        removeAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v1.json"
+        );
+        removeAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v2.json"
+        );
+        removeAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v3.json"
+        );
+        removeAxiosMock(
+          "https://mainnet.cash/.well-known/bitcoin-cash-metadata-registry_v4.json"
+        );
+      },
+      [process.env.ALICE_ID, registry]
+    );
+  });
+});