mainnet-js 3.1.7 → 4.0.0-next.10

package/src/message/signed.ts

@@ -1,201 +0,0 @@
-import {
-  assertSuccess,
-  base64ToBin,
-  bigIntToCompactUint,
-  binToBase64,
-  decodeCashAddress,
-  encodeCashAddress,
-  RecoveryId,
-  secp256k1,
-  sha256,
-  utf8ToBin,
-} from "@bitauth/libauth";
-
-import { hash160 } from "../util/hash160.js";
-import {
-  SignedMessageI,
-  SignedMessageResponseI,
-  VerifyMessageResponseI,
-} from "./interface.js";
-
-/**
- * message_magic - Add "Magic", per standard bitcoin message signing.
- *
- * In this case, the magic is simply adding the number 24 as binary "\x18", and "Bitcoin Signed Message\n" followed
- * by the size of the message in Bitcoin's "varint" format followed by the message encoded as binary.
- *
- * @param {str} string    The string to add the magic syntax to.
- *
- * @returns a promise to the string as binary array with magic syntax
- */
-// see    https://github.com/Electron-Cash/Electron-Cash/blob/49f9f672364f50053a026e4a5cb30e92db2d195d/electroncash/bitcoin.py#L524
-function message_magic(str: string) {
-  const msgBytes = utf8ToBin(str);
-  const payload = `\x18Bitcoin Signed Message:\n`;
-  return new Uint8Array([
-    ...utf8ToBin(payload),
-    ...bigIntToCompactUint(BigInt(msgBytes.length)),
-    ...msgBytes,
-  ]);
-}
-
-/**
- * hash_magic - Return the hash of the string that has undergone standard formatting
- *
- * @param {str} string    The string to hash
- *
- * @returns a promise to the hash of the string.
- */
-export function hash_message(str: string) {
-  const h = sha256.hash;
-  return h(h(message_magic(str)));
-}
-
-export class SignedMessage implements SignedMessageI {
-  /**
-   * sign - Calculate the recoverable signed checksum of a string message.
-   *
-   * @param {message} string          The
-   * @param {privateKey} Uint8Array   The private key to sign the message with
-   *
-   * @returns a promise to signature as a string
-   */
-  public sign(message: string, privateKey: Uint8Array): SignedMessageResponseI {
-    const messageHash = hash_message(message);
-    const rs = secp256k1.signMessageHashRecoverableCompact(
-      privateKey,
-      messageHash
-    );
-    if (typeof rs === "string") {
-      throw new Error(rs);
-    }
-    const sigDer = secp256k1.signMessageHashDER(
-      privateKey,
-      messageHash
-    ) as Uint8Array;
-    const sigSchnorr = secp256k1.signMessageHashSchnorr(
-      privateKey,
-      messageHash
-    ) as Uint8Array;
-    const electronEncoding = new Uint8Array([
-      ...[31 + rs.recoveryId],
-      ...rs.signature,
-    ]);
-    return {
-      raw: {
-        ecdsa: binToBase64(rs.signature),
-        schnorr: binToBase64(sigSchnorr),
-        der: binToBase64(sigDer),
-      },
-      details: {
-        recoveryId: rs.recoveryId,
-        compressed: true,
-        messageHash: binToBase64(messageHash),
-      },
-      signature: binToBase64(electronEncoding),
-    };
-  }
-
-  public static sign(message: string, privateKey: Uint8Array) {
-    return new this().sign(message, privateKey);
-  }
-  /**
-   * verify - Validate that the message is valid against a given signature
-   *
-   * @param {message} string     The message to verify as a utf8 string
-   * @param {signature} string   The signature as a base64 encoded string
-   * @param {cashaddr} string    The cashaddr to validate the signature against a recoverable signature.
-   * @param {publicKey} string    If publicKey is not recoverable from the signature type, the publicKey must be passed.
-   *
-   * @returns a promise to signature as a string
-   */
-  public verify(
-    message: string,
-    signature: string,
-    cashaddr?: string,
-    publicKey?: Uint8Array
-  ): VerifyMessageResponseI {
-    // Check that the signature is valid for the given message.
-    const messageHash = hash_message(message);
-    const sig = base64ToBin(signature);
-
-    let signatureValid = false;
-    let keyMatch = false;
-    let pkhMatch = false;
-    let pkh, signatureType;
-
-    if (sig.length === 65) {
-      const rawSig = sig.length === 65 ? sig.slice(1) : sig;
-      const recoveryId = sig.slice(0, 1)[0] - 31;
-      const recoveredPk = secp256k1.recoverPublicKeyCompressed(
-        rawSig,
-        recoveryId as RecoveryId,
-        messageHash
-      );
-      if (typeof recoveredPk === "string") {
-        throw new Error(recoveredPk);
-      }
-
-      pkh = hash160(recoveredPk);
-      signatureType = "recoverable";
-      signatureValid = secp256k1.verifySignatureCompact(
-        rawSig,
-        recoveredPk,
-        messageHash
-      );
-      if (cashaddr) {
-        // Validate that the signature actually matches the provided cashaddr
-        const decoded = assertSuccess(decodeCashAddress(cashaddr));
-
-        const resultingCashaddr = encodeCashAddress({
-          prefix: decoded.prefix,
-          type: decoded.type,
-          payload: pkh,
-        }).address;
-        if (resultingCashaddr === cashaddr) {
-          pkhMatch = true;
-        }
-      }
-    } else if (publicKey) {
-      if (secp256k1.verifySignatureDER(sig, publicKey, messageHash)) {
-        signatureType = "der";
-        signatureValid = true;
-        keyMatch = true;
-      } else if (
-        secp256k1.verifySignatureSchnorr(sig, publicKey, messageHash)
-      ) {
-        signatureType = "schnorr";
-        signatureValid = true;
-        keyMatch = true;
-      } else if (
-        secp256k1.verifySignatureCompact(sig, publicKey, messageHash)
-      ) {
-        signatureType = "ecdsa";
-        signatureValid = true;
-        keyMatch = true;
-      } else {
-        signatureType = "na";
-      }
-    }
-
-    return {
-      valid: signatureValid && (keyMatch || pkhMatch),
-      details: {
-        signatureValid: signatureValid,
-        signatureType: signatureType,
-        messageHash: binToBase64(messageHash),
-        publicKeyHashMatch: pkhMatch,
-        publicKeyMatch: keyMatch,
-      },
-    };
-  }
-
-  public static verify(
-    message: string,
-    signature: string,
-    cashaddr?: string,
-    publicKey?: Uint8Array
-  ) {
-    return new this().verify(message, signature, cashaddr, publicKey);
-  }
-}

package/src/mine/index.ts

@@ -1 +0,0 @@
-export * from "./mine.js";

package/src/mine/mine.test.ts

@@ -1,10 +0,0 @@
-import { mine } from "./mine";
-import { RegTestWallet } from "../wallet/Wif";
-
-describe(`Test Mining on Regtest`, () => {
-  test("Should mine two blocks", async () => {
-    const minerWallet = await RegTestWallet.newRandom();
-    const response = await mine({ cashaddr: minerWallet.cashaddr!, blocks: 2 });
-    expect(response.length).toBe(2);
-  });
-});

package/src/mine/mine.ts

@@ -1,42 +0,0 @@
-import { binToBase64, utf8ToBin } from "@bitauth/libauth";
-
-/**
- * Mine blocks to a regtest address
- *
- * @param cashaddr - the address to mine to
- * @param blocks - the number of blocks to mine
- *
- * @remarks
- * This function assumes a local regtest bitcoin node with RPC_* matching the docker configuration
- */
-export const mine = async ({
-  cashaddr,
-  blocks,
-}: {
-  cashaddr: string;
-  blocks: number;
-}): Promise<any> => {
-  const response = await fetch(`http://127.0.0.1:${process.env.RPC_PORT}/`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization:
-        "Basic " +
-        binToBase64(
-          utf8ToBin(`${process.env.RPC_USER}:${process.env.RPC_PASS}`)
-        ),
-    },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: "0",
-      method: "generatetoaddress",
-      params: {
-        nblocks: blocks,
-        address: cashaddr,
-      },
-    }),
-  });
-  const json = await response.json();
-
-  return json.result;
-};

package/src/network/Connection.test.ts

@@ -1,51 +0,0 @@
-import { initProviders, disconnectProviders, Connection } from "./Connection";
-import { RegTestWallet, TestNetWallet, Wallet } from "../wallet/Wif";
-
-beforeAll(async () => {
-  await initProviders();
-});
-
-afterAll(async () => {
-  await disconnectProviders();
-});
-
-test("Should connect to mainnet", async () => {
-  process.setMaxListeners(0);
-
-  let wallet = await Wallet.newRandom();
-  expect(wallet.provider == globalThis.BCH).toBeTruthy();
-  expect(await wallet.getBalance()).toBe(0n);
-
-  let height = await globalThis.BCH.getBlockHeight();
-  expect(height).toBeGreaterThan(5000);
-});
-
-test("Should use global provider when creating testnet wallet", async () => {
-  let wallet = await TestNetWallet.newRandom();
-  expect(wallet.provider == globalThis.tBCH).toBeTruthy();
-  expect(await wallet.getBalance()).toBe(0n);
-
-  let height = await globalThis.tBCH.getBlockHeight();
-  expect(height).toBeGreaterThan(114);
-});
-
-test.skip("Should lower overhead in creating wallets", async () => {
-  process.setMaxListeners(0);
-  for (let i = 0; i < 100; i++) {
-    let wallet = await RegTestWallet.newRandom();
-    expect(wallet.provider == globalThis.rBCH).toBeTruthy();
-    expect(await wallet.getBalance()).toBe(0n);
-  }
-
-  let height = await globalThis.rBCH.getBlockHeight();
-  expect(height).toBeGreaterThan(114);
-});
-
-test("Should create a new Connection", async () => {
-  let conn = new Connection("mainnet", "wss://bch.imaginary.cash:50004");
-  await conn.ready();
-  expect(conn.networkProvider == globalThis.BCH).toBeFalsy();
-  let blockheight = await conn.networkProvider.getBlockHeight();
-  expect(blockheight).toBeGreaterThan(10000);
-  expect(10001).toBeGreaterThan(10000);
-});

package/src/network/Connection.ts

@@ -1,73 +0,0 @@
-import { default as NetworkProvider } from "./NetworkProvider.js";
-import {
-  getNetworkProvider,
-  setGlobalProvider,
-  getGlobalProvider,
-  removeGlobalProvider,
-} from "./default.js";
-import { Network } from "../interface.js";
-import { networkTickerMap } from "./constant.js";
-import { prefixFromNetworkMap } from "../enum.js";
-import { CashAddressNetworkPrefix } from "@bitauth/libauth";
-
-export async function initProvider(network: Network) {
-  if (!getGlobalProvider(network)) {
-    const conn = new Connection(network);
-    const provider = (await conn.ready()).networkProvider;
-    setGlobalProvider(network, provider);
-    return provider;
-  }
-  return getGlobalProvider(network);
-}
-
-export async function initProviders(networks?: Network[]) {
-  networks = networks ? networks : (Object.keys(networkTickerMap) as Network[]);
-  let initPromises = networks.map((n) => initProvider(n));
-  await Promise.all(initPromises).catch((e) => {
-    console.warn(`Warning, couldn't establish a connection for ${e}`);
-  });
-}
-
-async function disconnectProvider(network: Network) {
-  const provider = getGlobalProvider(network);
-  if (provider) {
-    await provider.disconnect();
-    removeGlobalProvider(network);
-    return;
-  } else {
-    // console.warn(
-    //   `Ignoring attempt to disconnect non-existent ${network} provider`
-    // );
-    return true;
-  }
-}
-
-export async function disconnectProviders(networks?: Network[]) {
-  networks = networks ? networks : (Object.keys(networkTickerMap) as Network[]);
-  let disconnectPromises = networks.map((n) => disconnectProvider(n));
-  await Promise.all(disconnectPromises);
-}
-
-export class Connection {
-  public network: Network;
-  public servers?: string[];
-  public networkPrefix: CashAddressNetworkPrefix;
-  public networkProvider: NetworkProvider;
-
-  constructor(network?: Network, servers?: string[] | string) {
-    this.network = network ? network : "mainnet";
-    this.networkPrefix = prefixFromNetworkMap[this.network];
-    this.networkProvider = getNetworkProvider(this.network, servers, true);
-  }
-
-  public async ready() {
-    await this.networkProvider.connect();
-    await this.networkProvider.ready();
-    return this;
-  }
-
-  public async disconnect() {
-    await this.networkProvider.disconnect();
-    return this;
-  }
-}