mainnet-js 3.1.7 → 4.0.0-next.10

package/src/wallet/Util.test.ts

@@ -1,134 +0,0 @@
-import { initProviders, disconnectProviders } from "../network";
-import { RegTestWallet, Wallet } from "./Wif";
-import { mine } from "../mine";
-import { Config } from "../config";
-import { delay } from "../util/delay";
-
-beforeAll(async () => {
-  await initProviders();
-});
-afterAll(async () => {
-  await disconnectProviders();
-});
-
-describe("Utility tests", () => {
-  test("Should compute raw transaction hash", async () => {
-    const wallet = await RegTestWallet.newRandom();
-    expect(
-      await wallet.util.getTransactionHash(
-        "01000000015bb9142c960a838329694d3fe9ba08c2a6421c5158d8f7044cb7c48006c1b484000000006a4730440220229ea5359a63c2b83a713fcc20d8c41b20d48fe639a639d2a8246a137f29d0fc02201de12de9c056912a4e581a62d12fb5f43ee6c08ed0238c32a1ee769213ca8b8b412103bcf9a004f1f7a9a8d8acce7b51c983233d107329ff7c4fb53e44c855dbe1f6a4feffffff02c6b68200000000001976a9141041fb024bd7a1338ef1959026bbba860064fe5f88ac50a8cf00000000001976a91445dac110239a7a3814535c15858b939211f8529888ac61ee0700"
-      )
-    ).toBe("36a3692a41a8ac60b73f7f41ee23f5c917413e5b2fad9e44b34865bd0d601a3d");
-
-    // test static accessor
-    expect(
-      await RegTestWallet.util.getTransactionHash(
-        "01000000015bb9142c960a838329694d3fe9ba08c2a6421c5158d8f7044cb7c48006c1b484000000006a4730440220229ea5359a63c2b83a713fcc20d8c41b20d48fe639a639d2a8246a137f29d0fc02201de12de9c056912a4e581a62d12fb5f43ee6c08ed0238c32a1ee769213ca8b8b412103bcf9a004f1f7a9a8d8acce7b51c983233d107329ff7c4fb53e44c855dbe1f6a4feffffff02c6b68200000000001976a9141041fb024bd7a1338ef1959026bbba860064fe5f88ac50a8cf00000000001976a91445dac110239a7a3814535c15858b939211f8529888ac61ee0700"
-      )
-    ).toBe("36a3692a41a8ac60b73f7f41ee23f5c917413e5b2fad9e44b34865bd0d601a3d");
-  });
-
-  test("Should throw on non-existent transaction and invalid hash", async () => {
-    const wallet = await RegTestWallet.newRandom();
-    await expect(
-      wallet.util.decodeTransaction(
-        "36a3692a41a8ac60b73f7f41ee23f5c917413e5b2fad9e44b34865bd0d601a3d"
-      )
-    ).rejects.toThrowError("might not exist");
-    await expect(wallet.util.decodeTransaction("test")).rejects.toThrowError(
-      "Invalid tx hash"
-    );
-  });
-
-  test("Should get raw transaction", async () => {
-    let wallet = await RegTestWallet.fromId(process.env.ALICE_ID!);
-    const utxo = (await wallet.getUtxos())[0];
-    const transaction = await wallet.provider!.getRawTransactionObject(
-      utxo.txid
-    );
-    expect((await wallet.util.decodeTransaction(transaction.hash)).hash).toBe(
-      utxo.txid
-    );
-    expect((await wallet.util.decodeTransaction(transaction.hex)).txid).toBe(
-      utxo.txid
-    );
-
-    // test static accessor
-    expect(
-      (await RegTestWallet.util.decodeTransaction(transaction.hex)).txid
-    ).toBe(utxo.txid);
-  });
-
-  test("Should decode a transaction from fist block", async () => {
-    let wallet = await Wallet.newRandom();
-    const decoded = await wallet.util.decodeTransaction(
-      "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098"
-    );
-
-    expect(decoded.txid).toBe(
-      "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098"
-    );
-
-    // non-enriched vin entries don't carry vout fields (enforced by types)
-    expect((decoded.vin[0] as any).address).toBeUndefined();
-  });
-
-  test("Should decode a transaction and fetch input values and addresses", async () => {
-    const txHash =
-      "dc8f059900807c36941313f10b43ec049e23dfede4e09f8fbccc3871ed359fbe";
-    const decoded = await Wallet.util.decodeTransaction(txHash, true);
-    expect(decoded.vin[0].scriptPubKey.addresses[0]).toBeDefined();
-    expect(decoded.vin[0].value).toBeDefined();
-
-    //  uncomment next line
-    // expect(await Wallet.util.decodeTransaction(txHash)).toBe(await new Wallet().provider!.getRawTransactionObject(txHash));
-  });
-});
-
-describe("Dynamic confirmations via fetchHeight", () => {
-  test("confirmations defaults to 0 for decoded mempool transactions", async () => {
-    const wallet = await RegTestWallet.newRandom();
-    const decoded = await wallet.util.decodeTransaction(
-      "01000000015bb9142c960a838329694d3fe9ba08c2a6421c5158d8f7044cb7c48006c1b484000000006a4730440220229ea5359a63c2b83a713fcc20d8c41b20d48fe639a639d2a8246a137f29d0fc02201de12de9c056912a4e581a62d12fb5f43ee6c08ed0238c32a1ee769213ca8b8b412103bcf9a004f1f7a9a8d8acce7b51c983233d107329ff7c4fb53e44c855dbe1f6a4feffffff02c6b68200000000001976a9141041fb024bd7a1338ef1959026bbba860064fe5f88ac50a8cf00000000001976a91445dac110239a7a3814535c15858b939211f8529888ac61ee0700"
-    );
-    expect(decoded.confirmations).toBe(0);
-  });
-
-  test("confirmations is present on verbose server response", async () => {
-    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
-    const utxo = (await alice.getUtxos())[0];
-    const transaction = await alice.provider.getRawTransactionObject(utxo.txid);
-    expect(transaction.confirmations).toBeGreaterThan(0);
-  });
-
-  test("fetchHeight is not exposed in returned transaction", async () => {
-    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
-    const utxo = (await alice.getUtxos())[0];
-    const transaction = await alice.provider.getRawTransactionObject(utxo.txid);
-    expect((transaction as any).fetchHeight).toBeUndefined();
-  });
-
-  test("cached transaction has up-to-date confirmations", async () => {
-    const memoryCacheValue = Config.UseMemoryCache;
-    Config.UseMemoryCache = true;
-    try {
-      const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
-      const utxo = (await alice.getUtxos())[0];
-
-      // first fetch primes the cache
-      const tx1 = await alice.provider.getRawTransactionObject(utxo.txid);
-      const confirmations1 = tx1.confirmations;
-
-      // mine a block and wait for header subscription to propagate
-      await mine({ cashaddr: alice.cashaddr!, blocks: 1 });
-      await delay(1000);
-
-      // second fetch should hit cache but with updated confirmations
-      const tx2 = await alice.provider.getRawTransactionObject(utxo.txid);
-      expect(tx2.confirmations).toBe(confirmations1 + 1);
-      expect((tx2 as any).fetchHeight).toBeUndefined();
-    } finally {
-      Config.UseMemoryCache = memoryCacheValue;
-    }
-  });
-});

package/src/wallet/Util.ts

@@ -1,191 +0,0 @@
-import {
-  Transaction as LibAuthTransaction,
-  assertSuccess,
-  binToHex,
-  decodeTransaction as decodeTransactionLibAuth,
-  hexToBin,
-  isPayToPublicKey,
-  lockingBytecodeToAddressContents,
-  lockingBytecodeToCashAddress,
-  publicKeyToP2pkhCashAddress,
-} from "@bitauth/libauth";
-import { bchParam } from "../chain.js";
-import { NetworkType, prefixFromNetworkMap } from "../enum.js";
-import { getNetworkProvider } from "../network/default.js";
-import {
-  ElectrumRawTransaction,
-  ElectrumRawTransactionVin,
-  ElectrumRawTransactionVinWithValues,
-  ElectrumRawTransactionVout,
-  ElectrumRawTransactionWithInputValues,
-} from "../network/interface.js";
-import NetworkProvider from "../network/NetworkProvider.js";
-import { getTransactionHash } from "../util/transaction.js";
-
-/**
- * Class with various wallet utilities.
- */
-export class Util {
-  readonly network: NetworkType;
-  provider: NetworkProvider;
-
-  /**
-   * Initializes a wallet Util class.
-   *
-   * @param network     The network type to use. Defaults to mainnet.
-   */
-  constructor(network = NetworkType.Mainnet) {
-    this.network = network;
-    this.provider = getNetworkProvider(network);
-  }
-
-  public async getTransactionHash(rawTransactionHex: string): Promise<string> {
-    return getTransactionHash(rawTransactionHex);
-  }
-
-  public static async getTransactionHash(
-    rawTransactionHex: string
-  ): Promise<string> {
-    return getTransactionHash(rawTransactionHex);
-  }
-
-  public async decodeTransaction(
-    transactionHashOrHex: string,
-    loadInputValues: true
-  ): Promise<ElectrumRawTransactionWithInputValues>;
-  public async decodeTransaction(
-    transactionHashOrHex: string,
-    loadInputValues?: false
-  ): Promise<ElectrumRawTransaction>;
-  public async decodeTransaction(
-    transactionHashOrHex: string,
-    loadInputValues: boolean = false
-  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
-    let transactionHex: string;
-    let transactionBin: Uint8Array;
-    let txHash: string;
-
-    // raw transaction
-    if (transactionHashOrHex.length > 64) {
-      txHash = await this.getTransactionHash(transactionHashOrHex);
-      transactionBin = hexToBin(transactionHashOrHex);
-      transactionHex = transactionHashOrHex;
-    } else {
-      // tx hash, look up the raw transaction
-      txHash = transactionHashOrHex;
-      transactionHex = await this.provider.getRawTransaction(txHash);
-      transactionBin = hexToBin(transactionHex);
-    }
-
-    const result = decodeTransactionLibAuth(transactionBin);
-    if (typeof result === "string") {
-      throw Error(result);
-    }
-
-    const transaction = this.mapToElectrumRawTransaction(
-      result,
-      txHash,
-      transactionHex
-    );
-
-    if (loadInputValues) {
-      // get unique transaction hashes
-      const hashes = [...new Set(transaction.vin.map((val) => val.txid))];
-      const transactions = await Promise.all(
-        hashes.map((hash) => this.decodeTransaction(hash, false))
-      );
-      const transactionMap = new Map<string, ElectrumRawTransaction>();
-      transactions.forEach((val) => transactionMap.set(val.hash, val));
-
-      const enrichedVin: ElectrumRawTransactionVinWithValues[] =
-        transaction.vin.map((input) => {
-          const output = transactionMap
-            .get(input.txid)!
-            .vout.find((val) => val.n === input.vout)!;
-          return { ...input, ...output };
-        });
-
-      return { ...transaction, vin: enrichedVin };
-    }
-
-    return transaction;
-  }
-
-  public mapToElectrumRawTransaction(
-    transaction: LibAuthTransaction,
-    txHash: string,
-    txHex: string
-  ): ElectrumRawTransaction {
-    return {
-      blockhash: "",
-      blocktime: 0,
-      confirmations: 0,
-      time: 0,
-      hash: txHash,
-      hex: txHex,
-      txid: txHash,
-      locktime: transaction.locktime,
-      version: transaction.version,
-      size: txHex.length / 2,
-      vin: transaction.inputs.map(
-        (input): ElectrumRawTransactionVin => ({
-          scriptSig: {
-            asm: "",
-            hex: binToHex(input.unlockingBytecode),
-          },
-          sequence: input.sequenceNumber,
-          txid: binToHex(input.outpointTransactionHash),
-          vout: input.outpointIndex,
-        })
-      ),
-      vout: transaction.outputs.map(
-        (output, index): ElectrumRawTransactionVout => ({
-          n: index,
-          scriptPubKey: {
-            addresses: [
-              isPayToPublicKey(output.lockingBytecode)
-                ? publicKeyToP2pkhCashAddress({
-                    publicKey: lockingBytecodeToAddressContents(
-                      output.lockingBytecode
-                    ).payload,
-                    prefix: prefixFromNetworkMap[this.network],
-                  }).address
-                : assertSuccess(
-                    lockingBytecodeToCashAddress({
-                      bytecode: output.lockingBytecode,
-                      prefix: prefixFromNetworkMap[this.network],
-                    })
-                  ).address,
-            ],
-            asm: "",
-            hex: binToHex(output.lockingBytecode),
-            reqSigs: 1,
-            type: "",
-          },
-          value: Number(output.valueSatoshis) / Number(bchParam.subUnits),
-        })
-      ),
-    };
-  }
-
-  public static async decodeTransaction(
-    transactionHashOrHex: string,
-    loadInputValues: true,
-    network?: NetworkType
-  ): Promise<ElectrumRawTransactionWithInputValues>;
-  public static async decodeTransaction(
-    transactionHashOrHex: string,
-    loadInputValues?: false,
-    network?: NetworkType
-  ): Promise<ElectrumRawTransaction>;
-  public static async decodeTransaction(
-    transactionHashOrHex: string,
-    loadInputValues: boolean = false,
-    network?: NetworkType
-  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
-    if (loadInputValues) {
-      return new this(network).decodeTransaction(transactionHashOrHex, true);
-    }
-    return new this(network).decodeTransaction(transactionHashOrHex);
-  }
-}

package/src/wallet/WalletCache.test.ts

@@ -1,45 +0,0 @@
-import { RegTestWallet, RegTestWifWallet } from "./Wif";
-import { RegTestWatchWallet } from "./Watch";
-import { RegTestHDWallet } from "./HDWallet";
-
-describe("Wallet cache initialization", () => {
-  test("Seed wallet should have walletCache with at least one entry", async () => {
-    const wallet = await RegTestWallet.newRandom();
-    expect(wallet.walletCache).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)!.privateKey).toBeDefined();
-  });
-
-  test("Wif wallet should have walletCache with at least one entry", async () => {
-    const wallet = await RegTestWifWallet.newRandom();
-    expect(wallet.walletCache).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)!.privateKey).toBeDefined();
-  });
-
-  test("Wif wallet from ID should have walletCache with at least one entry", async () => {
-    const wallet = await RegTestWallet.fromId(
-      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
-    );
-    expect(wallet.walletCache).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)!.privateKey).toBeDefined();
-  });
-
-  test("HD wallet should have walletCache with at least one entry", async () => {
-    const wallet = await RegTestHDWallet.newRandom();
-    expect(wallet.walletCache).toBeDefined();
-    const depositAddr = wallet.getDepositAddress();
-    expect(wallet.walletCache!.get(depositAddr)).toBeDefined();
-    expect(wallet.walletCache!.get(depositAddr)!.privateKey).toBeDefined();
-    await wallet.stop();
-  });
-
-  test("Watch wallet should have empty walletCache", async () => {
-    const wallet = await RegTestWatchWallet.watchOnly(
-      "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0"
-    );
-    expect(wallet.walletCache).toBeDefined();
-    expect(wallet.walletCache!.get(wallet.cashaddr)).toBeUndefined();
-  });
-});