mainnet-js 3.1.7 → 4.0.0-next.10

package/src/util/checkWifNetwork.ts

@@ -1,24 +0,0 @@
-import { NetworkType } from "../enum.js";
-
-export function checkWifNetwork(
-  walletImportFormatString: string,
-  networkType: NetworkType
-) {
-  if (
-    !(
-      walletImportFormatString[0] === "L" || walletImportFormatString[0] === "K"
-    ) &&
-    networkType === NetworkType.Mainnet
-  ) {
-    throw Error(
-      `Mainnet type wif ${walletImportFormatString} passed, should start with L or K`
-    );
-  } else if (
-    walletImportFormatString[0] !== "c" &&
-    networkType === NetworkType.Testnet
-  ) {
-    throw Error(
-      `Testnet type wif ${walletImportFormatString} passed, should start with c`
-    );
-  }
-}

package/src/util/convert.test.ts

@@ -1,46 +0,0 @@
-import { convert } from "./convert";
-import { ExchangeRate } from "../rate/ExchangeRate";
-
-test("Should get price sat in usd", async () => {
-  let rate = await ExchangeRate.get("usd");
-  let usd = await convert(100000000, "sat", "usd");
-  expect(Math.round(rate)).toBeLessThan(usd + 1);
-  expect(Math.round(rate)).toBeGreaterThan(usd - 1);
-});
-
-test("Should get of bch in usd", async () => {
-  let rate = await ExchangeRate.get("usd");
-  let usd = await convert(1, "bch", "usd");
-  expect(Math.round(rate)).toBeLessThan(usd + 1);
-  expect(Math.round(rate)).toBeGreaterThan(usd - 1);
-});
-
-test("Should get usd value in fixed format", async () => {
-  let usd = await convert(1, "bch", "usd");
-  expect(usd.toFixed(2)).toMatch(/^\d+\.\d+?$/);
-});
-
-test("Should get price in usd in bch", async () => {
-  let rate = await ExchangeRate.get("usd");
-  let unity = await convert(rate, "usd", "bch");
-  expect(unity).toBeLessThan(1.01);
-  expect(unity).toBeGreaterThan(0.99);
-});
-
-test("Should convert in full loop", async () => {
-  let usd = await convert(1, "bch", "usd");
-  let sat = await convert(usd, "USD", "sat");
-  let bch = await convert(sat, "sat", "BCH");
-  expect(bch).toBeLessThan(1.01);
-  expect(bch).toBeGreaterThan(0.99);
-});
-
-test("Should convert all the BCH from sat to bch", async () => {
-  let bch = await convert(21000000 * 100000000, "sat", "BCH");
-  expect(bch).toBe(21000000);
-});
-
-test("Should convert BCH to EUR", async () => {
-  let eur = await convert(1, "BCH", "EUR");
-  expect(eur).toBeGreaterThan(0);
-});

package/src/util/convert.ts

@@ -1,50 +0,0 @@
-import { bchParam } from "../chain.js";
-import { amountInSatoshi } from "./amountInSatoshi.js";
-import { satoshiToAmount } from "./satoshiToAmount.js";
-
-/**
- * convert transforms unit of measurement for some monetary value
- *
- * @param {value} number           amount to convert
- * @param {from} any               unit of measurement to convert from
- * @param {to} any                 unit of measurement to convert to
- *
- * @returns a promise to the value in "to" units
- */
-export async function convert(
-  value: number,
-  from: any,
-  to: any
-): Promise<number> {
-  let satoshi = await amountInSatoshi(value, from);
-  return satoshiToAmount(satoshi, to);
-}
-
-export async function convertObject({
-  value,
-  from,
-  to,
-}: {
-  value: number;
-  from: any;
-  to: any;
-}) {
-  return await convert(value, from, to);
-}
-
-// sats -> bch
-export function toBch(sats: bigint): number {
-  return Number(sats) / Number(bchParam.subUnits);
-}
-
-// bch -> sats
-export function toSat(bch: string | number): bigint {
-  return BigInt(Math.round(Number(bch) * Number(bchParam.subUnits)));
-}
-
-export async function toCurrency(
-  sats: bigint,
-  currency: string
-): Promise<number> {
-  return convert(Number(sats), "sat", currency);
-}

package/src/util/delay.ts

@@ -1,3 +0,0 @@
-export function delay(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/util/deriveCashaddr.test.ts

@@ -1,164 +0,0 @@
-import { RegTestWallet, Wallet } from "../wallet/Wif";
-import {
-  convertAddress,
-  deriveCashaddr,
-  deriveTokenaddr,
-  isTokenaddr,
-  isValidAddress,
-  toCashaddr,
-  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(
-    wallet.cashaddr!
-  );
-  expect(deriveTokenaddr(wallet.privateKey!, wallet.networkPrefix)).toBe(
-    wallet.tokenaddr!
-  );
-  expect(deriveTokenaddr(wallet.publicKey!, wallet.networkPrefix)).toBe(
-    wallet.tokenaddr!
-  );
-  expect(
-    deriveTokenaddr(wallet.publicKeyCompressed!, wallet.networkPrefix)
-  ).toBe(wallet.tokenaddr!);
-  expect(deriveTokenaddr(wallet.publicKeyHash!, wallet.networkPrefix)).toBe(
-    wallet.tokenaddr!
-  );
-});
-
-test("Test address conversion", async () => {
-  const wallet = await RegTestWallet.watchOnly(process.env.ADDRESS!);
-
-  // 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(
-    "bchreg:zpttdv3qg2usm4nm7talhxhl05mlhms3ysjm0q59vu"
-  );
-
-  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("asdf")).toBe(false);
-});

package/src/util/deriveCashaddr.ts

@@ -1,143 +0,0 @@
-import {
-  CashAddressNetworkPrefix,
-  CashAddressType,
-  decodeCashAddress,
-  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 {
-  const result = decodeCashAddress(cashaddr);
-  if (typeof result === "string") {
-    return false;
-  }
-
-  return true;
-}
-
-export function deriveCashaddr(
-  privateKey: Uint8Array,
-  networkPrefix: CashAddressNetworkPrefix
-): string {
-  let publicKey = secp256k1.derivePublicKeyCompressed(privateKey);
-  if (typeof publicKey === "string") {
-    throw new Error(publicKey);
-  }
-  let pkh = hash160(publicKey);
-  return encodeCashAddress({
-    prefix: networkPrefix,
-    type: CashAddressType.p2pkh,
-    payload: pkh,
-  }).address;
-}
-
-export function deriveTokenaddr(
-  key: Uint8Array,
-  networkPrefix: CashAddressNetworkPrefix
-): string {
-  let publicKeyHash: Uint8Array;
-  // private key
-  if (key.length === 32) {
-    let publicKeyCompressed = secp256k1.derivePublicKeyCompressed(key);
-    if (typeof publicKeyCompressed === "string") {
-      throw new Error(publicKeyCompressed);
-    }
-    publicKeyHash = hash160(publicKeyCompressed);
-  } else if (key.length === 65) {
-    // uncompressed public key
-    let publicKeyCompressed = secp256k1.compressPublicKey(key);
-    if (typeof publicKeyCompressed === "string") {
-      throw new Error(publicKeyCompressed);
-    }
-    publicKeyHash = hash160(publicKeyCompressed);
-  } else if (key.length === 33) {
-    // compressed public key
-    publicKeyHash = hash160(key);
-  } else if (key.length === 20) {
-    // public key hash
-    publicKeyHash = key;
-  } else {
-    throw new Error("Unsupported type of key");
-  }
-
-  return encodeCashAddress({
-    prefix: networkPrefix,
-    type: CashAddressType.p2pkhWithTokens,
-    payload: publicKeyHash,
-  }).address;
-}
-
-function decodeAddress(address: string): DecodedCashAddress {
-  const result = decodeCashAddress(address);
-  if (typeof result === "string") {
-    throw new Error(result);
-  }
-  return result;
-}
-
-export function toCashaddr(address: string): string {
-  if (address.indexOf(":q") > 0 || address.indexOf(":p") > 0) {
-    return address;
-  }
-
-  const result = decodeAddress(address);
-
-  return encodeCashAddress({
-    prefix: result.prefix as CashAddressNetworkPrefix,
-    type: result.type.replace("WithTokens", "") as CashAddressType,
-    payload: result.payload,
-  }).address;
-}
-
-export function toTokenaddr(address: string): string {
-  if (address.indexOf(":z") > 0 || address.indexOf(":r") > 0) {
-    return address;
-  }
-
-  const result = decodeAddress(address);
-
-  return encodeCashAddress({
-    prefix: result.prefix as CashAddressNetworkPrefix,
-    type: (result.type.replace("WithTokens", "") +
-      "WithTokens") as CashAddressType,
-    payload: result.payload,
-  }).address;
-}
-
-export function isTokenaddr(address: string): boolean {
-  const result = decodeAddress(address);
-
-  return result.type.endsWith("WithTokens");
-}
-
-// 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 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) {
-  if (enforce && !isTokenaddr(cashaddr)) {
-    throw new Error("Error trying to send to a non-tokenaware cash address");
-  }
-}

package/src/util/deriveLockscript.ts

@@ -1,16 +0,0 @@
-import { cashAddressToLockingBytecode } from "@bitauth/libauth";
-
-/**
- * Helper function to convert an address to a locking script
- *
- * @param address   Address to convert to locking script
- *
- * @returns a locking script corresponding to the passed address
- */
-export function deriveLockscript(address: string): Uint8Array {
-  const result = cashAddressToLockingBytecode(address);
-
-  if (typeof result === "string") throw new Error(result);
-
-  return result.bytecode;
-}

package/src/util/deriveNetwork.ts

@@ -1,19 +0,0 @@
-import { derivePrefix } from "./derivePublicKeyHash.js";
-import { networkPrefixMap } from "../enum.js";
-
-// This function if for assuring that a list of addresses are on the name network
-// for a single address use: networkPrefixMap[derivePrefix(address)]
-export function derivedNetwork(addresses: string[]) {
-  let networks = addresses.map(
-    (address) => networkPrefixMap[derivePrefix(address)]
-  );
-  // Get a unique set of networks requested
-  let networkSet = new Set(networks);
-  if (networkSet.size > 1) {
-    throw Error("Addresses are not on the same network");
-  } else if (networkSet.size === 0) {
-    throw Error("No address network was derived");
-  } else {
-    return networkSet.values().next().value;
-  }
-}

package/src/util/derivePublicKeyHash.test.ts

@@ -1,55 +0,0 @@
-import {
-  hexToBin,
-  binToHex,
-  instantiateRipemd160,
-  instantiateSha256,
-  instantiateSecp256k1,
-} from "@bitauth/libauth";
-import { Wallet } from "../wallet/Wif";
-import { derivePublicKeyHash } from "./derivePublicKeyHash";
-
-test("Should return the a public key hash", async () => {
-  let pkh = derivePublicKeyHash(
-    "bchreg:pz0z7u9p96h2p6hfychxdrmwgdlzpk5luc22ykt2z6"
-  );
-  let pkh2 = derivePublicKeyHash("pz0z7u9p96h2p6hfychxdrmwgdlzpk5luc22ykt2z6");
-  expect(pkh.length).toBe(20);
-  expect(pkh2.length).toBe(20);
-  expect(pkh).toStrictEqual(pkh2);
-});
-
-test("Should calculate public key hash using via hash160", async () => {
-  const ripemd160 = await instantiateRipemd160();
-  const sha256 = await instantiateSha256();
-  let pkh2 = ripemd160.hash(
-    sha256.hash(
-      hexToBin(
-        "02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737"
-      )
-    )
-  );
-  expect(pkh2.length).toBe(20);
-  expect(binToHex(pkh2)).toEqual("93ce48570b55c42c2af816aeaba06cfee1224fae");
-});
-
-test("Should calculate public key hash consistent with hash160", async () => {
-  const ripemd160 = await instantiateRipemd160();
-  const sha256 = await instantiateSha256();
-  const secp256k1 = await instantiateSecp256k1();
-  let w = await Wallet.fromId(
-    "seed:mainnet:abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
-  );
-  // using cashaddr functoin
-  let pkh = derivePublicKeyHash(w.getDepositAddress());
-  // manually from compressed public key
-  let publicKeyCompressed = secp256k1.derivePublicKeyCompressed(w.privateKey!);
-  if (typeof publicKeyCompressed === "string") {
-    throw new Error(publicKeyCompressed);
-  }
-  let pkh2 = ripemd160.hash(sha256.hash(publicKeyCompressed));
-  let pkh3 = w.publicKeyHash!;
-  expect(pkh2.length).toBe(20);
-  expect(binToHex(pkh)).toEqual("d986ed01b7a22225a70edbf2ba7cfb63a15cb3aa");
-  expect(binToHex(pkh2)).toEqual("d986ed01b7a22225a70edbf2ba7cfb63a15cb3aa");
-  expect(binToHex(pkh3)).toEqual("d986ed01b7a22225a70edbf2ba7cfb63a15cb3aa");
-});

package/src/util/derivePublicKeyHash.ts

@@ -1,64 +0,0 @@
-import {
-  CashAddressNetworkPrefix,
-  decodeCashAddressFormat,
-  decodeCashAddressFormatWithoutPrefix,
-} from "@bitauth/libauth";
-
-/**
- * Helper function to convert an address to a public key hash
- *
- * @param address   Address to convert to a hash
- *
- * @returns a public key hash corresponding to the passed address
- */
-export function derivePublicKeyHash(address: string): Uint8Array {
-  let result:
-    | string
-    | {
-        payload: Uint8Array;
-        prefix: string;
-        version: number;
-      };
-
-  // If the address has a prefix decode it as is
-  if (address.includes(":")) {
-    result = decodeCashAddressFormat(address);
-  }
-  // otherwise, derive the network from the address without prefix
-  else {
-    result = decodeCashAddressFormatWithoutPrefix(address);
-  }
-
-  if (typeof result === "string") throw new Error(result);
-
-  // return the public key hash
-  return result.payload;
-}
-
-/**
- * Helper function to convert an address prefix
- *
- * @param address   Address with or without prefix
- *
- * @returns the address prefix
- */
-export function derivePrefix(address: string): CashAddressNetworkPrefix {
-  let result:
-    | string
-    | {
-        payload: Uint8Array;
-        prefix: string;
-        version: number;
-      };
-
-  if (address.includes(":")) {
-    result = decodeCashAddressFormat(address);
-  } else {
-    result = decodeCashAddressFormatWithoutPrefix(address);
-  }
-
-  if (typeof result === "string") throw new Error(result);
-
-  // TODO pass the network in and check it or raise Error
-  return result.prefix as CashAddressNetworkPrefix;
-}

package/src/util/floor.test.ts

@@ -1,21 +0,0 @@
-import { floor } from "./floor";
-
-test("Should return a number floored to 2 precision", async () => {
-  let result = floor(5.019, 2).toString();
-  expect(result).toStrictEqual("5.01");
-});
-
-test("Should return a number floored to 3 precision", async () => {
-  let result = floor(5.0199, 3).toString();
-  expect(result).toStrictEqual("5.019");
-});
-
-test("Should return a number floored to 2 precision", async () => {
-  let result = floor(5.0200001, 2).toString();
-  expect(result).toStrictEqual("5.02");
-});
-
-test("Should return a number floored to 0 precision", async () => {
-  let result = floor(5.996, 0).toString();
-  expect(result).toStrictEqual("5");
-});

package/src/util/floor.ts

@@ -1,4 +0,0 @@
-export function floor(value, precision) {
-  var multiplier = Math.pow(10, precision || 0);
-  return Math.floor(value * multiplier) / multiplier;
-}