mainnet-js 2.7.4 → 2.7.6

package/src/util/deriveCashaddr.test.ts

@@ -1,5 +1,6 @@
 import { RegTestWallet, Wallet } from "../wallet/Wif";
 import {
+  convertAddress,
   deriveCashaddr,
   deriveTokenaddr,
   isTokenaddr,
@@ -8,6 +9,46 @@ import {
   toTokenaddr,
 } from "./deriveCashaddr";
 
+const p2pkhAddress = "bitcoincash:qpttdv3qg2usm4nm7talhxhl05mlhms3ystlwcm8h4";
+const p2pkhTokenAddress =
+  "bitcoincash:zpttdv3qg2usm4nm7talhxhl05mlhms3ysv4ax4pgx";
+
+const testnetP2pkhAddress =
+  "bchtest:qpttdv3qg2usm4nm7talhxhl05mlhms3ys0d2lessf";
+const testnetP2pkhTokenAddress =
+  "bchtest:zpttdv3qg2usm4nm7talhxhl05mlhms3ysg8ephk06";
+
+const regtestP2pkhAddress = "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0";
+const regtestP2pkhTokenAddress =
+  "bchreg:zpttdv3qg2usm4nm7talhxhl05mlhms3ysjm0q59vu";
+
+const p2shAddress = "bitcoincash:ppvamrzvn62c85tv0y4ncdxyy77csxk7qgcjrpwp98";
+const p2shTokenAddress =
+  "bitcoincash:rpvamrzvn62c85tv0y4ncdxyy77csxk7qglcslq865";
+
+const testnetP2shAddress = "bchtest:ppvamrzvn62c85tv0y4ncdxyy77csxk7qguq8xvkzm";
+const testnetP2shTokenAddress =
+  "bchtest:rpvamrzvn62c85tv0y4ncdxyy77csxk7qgm25czsag";
+
+const regtestP2shAddress = "bchreg:ppvamrzvn62c85tv0y4ncdxyy77csxk7qgxu3809pa";
+const regtestP2shTokenAddress =
+  "bchreg:rpvamrzvn62c85tv0y4ncdxyy77csxk7qgpkzepr7w";
+
+const p2sh32Address =
+  "bitcoincash:pww87w869tuuzw4avtyxtlwhq32l25xkyy9n3xhzfelhj0d3vm8xx5auz6k7z";
+const p2sh32TokenAddress =
+  "bitcoincash:rww87w869tuuzw4avtyxtlwhq32l25xkyy9n3xhzfelhj0d3vm8xxxwqrrh8f";
+
+const testnetP2sh32Address =
+  "bchtest:pww87w869tuuzw4avtyxtlwhq32l25xkyy9n3xhzfelhj0d3vm8xxh6duz9ts";
+const testnetP2sh32TokenAddress =
+  "bchtest:rww87w869tuuzw4avtyxtlwhq32l25xkyy9n3xhzfelhj0d3vm8xx9f3amyjm";
+
+const regtestP2sh32Address =
+  "bchreg:pww87w869tuuzw4avtyxtlwhq32l25xkyy9n3xhzfelhj0d3vm8xxzslk9juc";
+const regtestP2sh32TokenAddress =
+  "bchreg:rww87w869tuuzw4avtyxtlwhq32l25xkyy9n3xhzfelhj0d3vm8xxsrrhun9n";
+
 test("Should derive cashaddr", async () => {
   const wallet = await Wallet.newRandom();
   expect(deriveCashaddr(wallet.privateKey!, wallet.networkPrefix)).toBe(
@@ -29,23 +70,95 @@ test("Should derive cashaddr", async () => {
 
 test("Test address conversion", async () => {
   const wallet = await RegTestWallet.watchOnly(process.env.ADDRESS!);
-  expect(toTokenaddr(wallet.cashaddr!)).toBe(wallet.tokenaddr);
-  expect(toCashaddr(wallet.tokenaddr!)).toBe(wallet.cashaddr);
 
-  expect(toCashaddr(wallet.tokenaddr!)).toBe(
+  // p2pkh
+  expect(toTokenaddr(wallet.cashaddr)).toBe(wallet.tokenaddr);
+  expect(toCashaddr(wallet.cashaddr)).toBe(wallet.cashaddr);
+
+  // p2pkh with tokens
+  expect(toCashaddr(wallet.tokenaddr)).toBe(wallet.cashaddr);
+  expect(toTokenaddr(wallet.tokenaddr)).toBe(wallet.tokenaddr);
+
+  // p2sh
+  expect(toCashaddr(p2shAddress)).toBe(p2shAddress);
+  expect(toTokenaddr(p2shAddress)).toBe(p2shTokenAddress);
+
+  // p2sh with tokens
+  expect(toCashaddr(p2shTokenAddress)).toBe(p2shAddress);
+  expect(toTokenaddr(p2shTokenAddress)).toBe(p2shTokenAddress);
+
+  // p2sh32
+  expect(toCashaddr(p2sh32Address)).toBe(p2sh32Address);
+  expect(toTokenaddr(p2sh32Address)).toBe(p2sh32TokenAddress);
+
+  // p2sh32 with tokens
+  expect(toCashaddr(p2sh32TokenAddress)).toBe(p2sh32Address);
+  expect(toTokenaddr(p2sh32TokenAddress)).toBe(p2sh32TokenAddress);
+
+  expect(toCashaddr(wallet.tokenaddr)).toBe(
     "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0"
   );
-  expect(toTokenaddr(wallet.cashaddr!)).toBe(
+  expect(toTokenaddr(wallet.cashaddr)).toBe(
     "bchreg:zpttdv3qg2usm4nm7talhxhl05mlhms3ysjm0q59vu"
   );
 
-  expect(isTokenaddr(wallet.cashaddr!)).toBe(false);
-  expect(isTokenaddr(wallet.tokenaddr!)).toBe(true);
+  expect(isTokenaddr(wallet.cashaddr)).toBe(false);
+  expect(isTokenaddr(wallet.tokenaddr)).toBe(true);
+});
+
+test("Test address network conversion", async () => {
+  expect(convertAddress(p2pkhAddress, "mainnet")).toBe(p2pkhAddress);
+  expect(convertAddress(p2pkhAddress, "testnet")).toBe(testnetP2pkhAddress);
+  expect(convertAddress(p2pkhAddress, "regtest")).toBe(regtestP2pkhAddress);
+
+  expect(convertAddress(p2pkhTokenAddress, "mainnet")).toBe(p2pkhTokenAddress);
+  expect(convertAddress(p2pkhTokenAddress, "testnet")).toBe(
+    testnetP2pkhTokenAddress
+  );
+  expect(convertAddress(p2pkhTokenAddress, "regtest")).toBe(
+    regtestP2pkhTokenAddress
+  );
+
+  expect(convertAddress(p2shAddress, "mainnet")).toBe(p2shAddress);
+  expect(convertAddress(p2shAddress, "testnet")).toBe(testnetP2shAddress);
+  expect(convertAddress(p2shAddress, "regtest")).toBe(regtestP2shAddress);
+
+  expect(convertAddress(p2shTokenAddress, "mainnet")).toBe(p2shTokenAddress);
+  expect(convertAddress(p2shTokenAddress, "testnet")).toBe(
+    testnetP2shTokenAddress
+  );
+  expect(convertAddress(p2shTokenAddress, "regtest")).toBe(
+    regtestP2shTokenAddress
+  );
+
+  expect(convertAddress(p2sh32Address, "mainnet")).toBe(p2sh32Address);
+  expect(convertAddress(p2sh32Address, "testnet")).toBe(testnetP2sh32Address);
+  expect(convertAddress(p2sh32Address, "regtest")).toBe(regtestP2sh32Address);
+
+  expect(convertAddress(p2sh32TokenAddress, "mainnet")).toBe(
+    p2sh32TokenAddress
+  );
+  expect(convertAddress(p2sh32TokenAddress, "testnet")).toBe(
+    testnetP2sh32TokenAddress
+  );
+  expect(convertAddress(p2sh32TokenAddress, "regtest")).toBe(
+    regtestP2sh32TokenAddress
+  );
+
+  // change token awareness
+  expect(convertAddress(p2pkhAddress, "mainnet", true)).toBe(p2pkhTokenAddress);
+  expect(convertAddress(p2pkhAddress, "mainnet", false)).toBe(p2pkhAddress);
+  expect(convertAddress(p2pkhTokenAddress, "mainnet", true)).toBe(
+    p2pkhTokenAddress
+  );
+  expect(convertAddress(p2pkhTokenAddress, "mainnet", false)).toBe(
+    p2pkhAddress
+  );
 });
 
 test("Test isValidAddress", async () => {
   const wallet = await RegTestWallet.watchOnly(process.env.ADDRESS!);
-  expect(isValidAddress(wallet.cashaddr!)).toBe(true);
-  expect(isValidAddress(wallet.tokenaddr!)).toBe(true);
+  expect(isValidAddress(wallet.cashaddr)).toBe(true);
+  expect(isValidAddress(wallet.tokenaddr)).toBe(true);
   expect(isValidAddress("asdf")).toBe(false);
 });

package/src/util/deriveCashaddr.ts

@@ -1,17 +1,13 @@
 import {
   CashAddressNetworkPrefix,
-  encodeCashAddress,
   CashAddressType,
-  secp256k1,
-  decodeCashAddressFormat,
-  decodeCashAddressFormatWithoutPrefix,
-  CashAddressVersionByte,
   decodeCashAddress,
-  cashAddressTypeBitsToType,
-  decodeCashAddressVersionByte,
-  assertSuccess,
+  DecodedCashAddress,
+  encodeCashAddress,
+  secp256k1,
 } from "@bitauth/libauth";
-
+import { prefixFromNetworkMap } from "../enum.js";
+import { Network } from "../interface.js";
 import { hash160 } from "./hash160.js";
 
 export function isValidAddress(cashaddr: string): boolean {
@@ -75,85 +71,61 @@ export function deriveTokenaddr(
   }).address;
 }
 
-export function toCashaddr(tokenaddr: string): string {
-  let result:
-    | string
-    | { payload: Uint8Array; prefix: string; version: number }
-    | undefined;
-
-  // If the address has a prefix decode it as is
-  if (tokenaddr.includes(":")) {
-    result = decodeCashAddressFormat(tokenaddr);
-  }
-  // otherwise, derive the network from the tokenaddr without prefix
-  else {
-    result = decodeCashAddressFormatWithoutPrefix(tokenaddr);
+function decodeAddress(address: string): DecodedCashAddress {
+  const result = decodeCashAddress(address);
+  if (typeof result === "string") {
+    throw new Error(result);
   }
+  return result;
+}
 
-  if (typeof result === "string") throw new Error(result);
+export function toCashaddr(address: string): string {
+  const result = decodeAddress(address);
 
   return encodeCashAddress({
     prefix: result.prefix as CashAddressNetworkPrefix,
-    type: CashAddressType.p2pkh,
+    type: result.type.replace("WithTokens", "") as CashAddressType,
     payload: result.payload,
   }).address;
 }
 
-export function toTokenaddr(cashaddr: string): string {
-  let result:
-    | string
-    | { payload: Uint8Array; prefix: string; version: number }
-    | undefined;
-
-  // If the address has a prefix decode it as is
-  if (cashaddr.includes(":")) {
-    result = decodeCashAddressFormat(cashaddr);
-  }
-  // otherwise, derive the network from the cashaddr without prefix
-  else {
-    result = decodeCashAddressFormatWithoutPrefix(cashaddr);
-  }
-
-  if (typeof result === "string") throw new Error(result);
+export function toTokenaddr(address: string): string {
+  const result = decodeAddress(address);
 
   return encodeCashAddress({
     prefix: result.prefix as CashAddressNetworkPrefix,
-    type: CashAddressType.p2pkhWithTokens,
+    type: (result.type.replace("WithTokens", "") +
+      "WithTokens") as CashAddressType,
     payload: result.payload,
   }).address;
 }
 
 export function isTokenaddr(address: string): boolean {
-  let result:
-    | string
-    | { payload: Uint8Array; prefix: string; version: number }
-    | undefined;
-
-  // If the address has a prefix decode it as is
-  if (address.includes(":")) {
-    result = decodeCashAddressFormat(address);
-  } else {
-    // otherwise, derive the network from the address without prefix
-    result = decodeCashAddressFormatWithoutPrefix(address);
-  }
-
-  if (typeof result === "string") throw new Error(result);
+  const result = decodeAddress(address);
 
-  const info = decodeCashAddressVersionByte(result.version);
-  if (typeof info === "string") throw new Error(info);
+  return result.type.endsWith("WithTokens");
+}
 
-  const type = cashAddressTypeBitsToType[
-    info.typeBits as keyof typeof cashAddressTypeBitsToType
-  ] as CashAddressType | undefined;
-  if (type === undefined) {
-    throw Error("Wrong cashaddress type");
-  }
+// This function converts a cash address to a cash address of the specified network.
+// If withTokens is true, it will return a token-aware address.
+// If withTokens is false, it will return a non-token-aware address.
+// If withTokens is undefined, it will not change the token-awareness.
+export function convertAddress(
+  address: string,
+  network: Network = "mainnet",
+  withTokens: boolean | undefined = undefined
+): string {
+  const result = decodeAddress(address);
 
-  return (
-    [CashAddressType.p2pkhWithTokens, CashAddressType.p2shWithTokens].indexOf(
-      type
-    ) !== -1
-  );
+  return encodeCashAddress({
+    prefix: prefixFromNetworkMap[network] as CashAddressNetworkPrefix,
+    type:
+      withTokens === undefined
+        ? result.type
+        : ((result.type.replace("WithTokens", "") +
+            (withTokens ? "WithTokens" : "")) as CashAddressType),
+    payload: result.payload,
+  }).address;
 }
 
 export function checkTokenaddr(cashaddr: string, enforce: boolean) {

package/dist/_67af-2.7.4.js

@@ -1,21 +0,0 @@
-/*
- * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
- * This devtool is neither made for production nor for readable output files.
- * It uses "eval()" calls to create a separate source file in the browser devtools.
- * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
- * or disable the default devtool with "devtool: false".
- * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
- */
-(self["webpackChunkmainnet_js"] = self["webpackChunkmainnet_js"] || []).push([["_67af"],{
-
-/***/ "?67af":
-/*!*******************************!*\
-  !*** child_process (ignored) ***!
-  \*******************************/
-/***/ (() => {
-
-eval("/* (ignored) */\n\n//# sourceURL=webpack://mainnet-js/child_process_(ignored)?");
-
-/***/ })
-
-}])