mainnet-js 0.4.30 → 0.4.34

package/src/wallet/Wif.ts

@@ -1,11 +1,18 @@
 //#region Imports
 // Stable
-import { instantiateSecp256k1, instantiateSha256 } from "@bitauth/libauth";
+import {
+  deriveHdPublicNodeIdentifier,
+  encodeHdPublicKey,
+  HdKeyNetwork,
+  instantiateSecp256k1,
+  instantiateSha256,
+} from "@bitauth/libauth";
 
 // Unstable?
 import {
   binToHex,
   CashAddressNetworkPrefix,
+  deriveHdPublicNode,
   decodePrivateKeyWif,
   encodePrivateKeyWif,
   deriveHdPrivateNodeFromSeed,
@@ -40,6 +47,7 @@ import {
   SendResponse,
   UtxoItem,
   UtxoResponse,
+  XPubKey,
 } from "./model";
 
 import {
@@ -92,7 +100,8 @@ import { generateRandomBytes } from "../util/randomBytes";
 import { SignedMessageI, SignedMessage } from "../message";
 import ElectrumNetworkProvider from "../network/ElectrumNetworkProvider";
 import { amountInSatoshi } from "../util/amountInSatoshi";
-import { DUST_UTXO_THRESHOLD } from "../constant";
+import { getXPubKey } from "../util/getXPubKey";
+import { DERIVATION_PATHS, DUST_UTXO_THRESHOLD } from "../constant";
 
 //#endregion Imports
 
@@ -105,6 +114,8 @@ const sha256Promise = instantiateSha256();
 export class Wallet extends BaseWallet {
   cashaddr?: string;
   derivationPath: string = "m/44'/0'/0'/0/0";
+  parentDerivationPath: string = "m/44'/0'/0'";
+  parentXPubKey?: string;
   privateKey?: Uint8Array;
   publicKeyCompressed?: Uint8Array;
   privateKeyWif?: string;
@@ -186,6 +197,10 @@ export class Wallet extends BaseWallet {
       network: this.network as any,
       seed: this.mnemonic ? this.getSeed().seed : undefined,
       derivationPath: this.mnemonic ? this.getSeed().derivationPath : undefined,
+      parentDerivationPath: this.mnemonic
+        ? this.getSeed().parentDerivationPath
+        : undefined,
+      parentXPubKey: this.parentXPubKey ? this.parentXPubKey : undefined,
       publicKey: this.publicKey ? binToHex(this.publicKey!) : undefined,
       publicKeyHash: binToHex(this.publicKeyHash!),
       privateKey: this.privateKey ? binToHex(this.privateKey!) : undefined,
@@ -319,19 +334,25 @@ export class Wallet extends BaseWallet {
   }
 
   private async _generateMnemonic() {
-    const crypto = await instantiateBIP32Crypto();
     this.mnemonic = generateMnemonic();
     let seed = mnemonicToSeedSync(this.mnemonic!);
+    let network = this.isTestnet ? "testnet" : "mainnet";
+    this.parentXPubKey = await getXPubKey(
+      seed,
+      this.parentDerivationPath,
+      network
+    );
+
+    const crypto = await instantiateBIP32Crypto();
     let hdNode = deriveHdPrivateNodeFromSeed(crypto, seed);
     if (!hdNode.valid) {
       throw Error("Invalid private key derived from mnemonic seed");
     }
 
-    let zerothChild = deriveHdPath(
-      crypto,
-      hdNode,
-      this.derivationPath
-    ) as HdPrivateNodeValid;
+    let zerothChild = deriveHdPath(crypto, hdNode, this.derivationPath);
+    if (typeof zerothChild === "string") {
+      throw Error(zerothChild);
+    }
     this.privateKey = zerothChild.privateKey;
 
     this.walletType = WalletTypeEnum.Seed;
@@ -353,6 +374,18 @@ export class Wallet extends BaseWallet {
     return super.fromId(walletId);
   };
 
+  public async getXPubKeys(paths?) {
+    if (this.mnemonic) {
+      if (paths) {
+        let xPubKeys = await this.deriveHdPaths(paths);
+        return [xPubKeys];
+      } else {
+        return await this.deriveHdPaths(DERIVATION_PATHS);
+      }
+    } else {
+      throw Error("xpubkeys can only be derived from seed type wallets.");
+    }
+  }
   // Initialize wallet from a mnemonic phrase
   protected async fromSeed(
     mnemonic: string,
@@ -369,20 +402,73 @@ export class Wallet extends BaseWallet {
     }
     if (derivationPath) {
       this.derivationPath = derivationPath;
+
+      // If the derivation path is for the first account child, set the parent derivation path
+      let path = derivationPath.split("/");
+      if (path.slice(-2).join("/") == "0/0") {
+        this.parentDerivationPath = path.slice(0, -2).join("/");
+      }
     }
 
-    let zerothChild = deriveHdPath(
-      crypto,
-      hdNode,
-      this.derivationPath
-    ) as HdPrivateNodeValid;
+    let zerothChild = deriveHdPath(crypto, hdNode, this.derivationPath);
+    if (typeof zerothChild === "string") {
+      throw Error(zerothChild);
+    }
     this.privateKey = zerothChild.privateKey;
 
+    let network = this.isTestnet ? "testnet" : "mainnet";
+    this.parentXPubKey = await getXPubKey(
+      seed,
+      this.parentDerivationPath,
+      network
+    );
+
     this.walletType = WalletTypeEnum.Seed;
     await this.deriveInfo();
     return this;
   }
 
+  // Get common xpub paths from zerothChild privateKey
+  public async deriveHdPaths(hdPaths: string[]): Promise<any[]> {
+    const crypto = await instantiateBIP32Crypto();
+    let seed = mnemonicToSeedSync(this.mnemonic!);
+    let hdNode = deriveHdPrivateNodeFromSeed(crypto, seed);
+    if (!hdNode.valid) {
+      throw Error("Invalid private key derived from mnemonic seed");
+    }
+
+    let result: any[] = [];
+
+    for (const path of hdPaths) {
+      if (path === "m") {
+        throw Error(
+          "Storing or sharing of parent public key may lead to loss of funds. Storing or sharing *root* parent public keys is strongly discouraged, although all parent keys have risk. See: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#implications"
+        );
+      }
+      let childNode = deriveHdPath(crypto, hdNode, path);
+      if (typeof childNode === "string") {
+        throw Error(childNode);
+      }
+      let node = deriveHdPublicNode(crypto, childNode);
+      if (typeof node === "string") {
+        throw Error(node);
+      }
+      let xPubKey = encodeHdPublicKey(crypto, {
+        network: this.network as HdKeyNetwork,
+        node: node,
+      });
+      let key = new XPubKey({
+        path: path,
+        xPubKey: xPubKey,
+      });
+
+      result.push(await key.ready());
+    }
+    return await Promise.all(result).then((result) => {
+      return result;
+    });
+  }
+
   // Initialize a watch only wallet from a cash addr
   protected async watchOnly(address: string): Promise<this> {
     this.walletType = WalletTypeEnum.Watch;
@@ -417,8 +503,7 @@ export class Wallet extends BaseWallet {
     const sha256 = await sha256Promise;
     let wifResult = decodePrivateKeyWif(sha256, secret);
 
-    const hasError = typeof wifResult === "string";
-    if (hasError) {
+    if (typeof wifResult === "string") {
       throw Error(wifResult as string);
     }
     let resultData: PrivateKeyI = wifResult as PrivateKeyI;
@@ -723,6 +808,8 @@ export class Wallet extends BaseWallet {
 
   /**
    * send Send some amount to an address
+   * this function processes the send requests, encodes the transaction, sends it to the network
+   * @returns (depending on the options parameter) the transaction id, new address balance and a link to the transaction on the blockchain explorer
    *
    * This is a first class function with REST analog, maintainers should strive to keep backward-compatibility
    *
@@ -735,14 +822,24 @@ export class Wallet extends BaseWallet {
       | SendRequestArray[],
     options?: SendRequestOptionsI
   ): Promise<SendResponse> {
-    let sendRequests = asSendRequestObject(requests);
-    let result = await this._processSendRequests(
-      sendRequests,
+    let encodedTransaction = await this.encodeTransaction(
+      requests,
       undefined,
       options
     );
+
+    const awaitTransactionPropagation =
+      !options ||
+      options.awaitTransactionPropagation === undefined ||
+      options.awaitTransactionPropagation;
+
+    const txId = await this.submitTransaction(
+      encodedTransaction,
+      awaitTransactionPropagation
+    );
+
     let resp = new SendResponse({});
-    resp.txId = result;
+    resp.txId = txId;
     const queryBalance =
       !options || options.queryBalance === undefined || options.queryBalance;
     if (queryBalance) {
@@ -752,6 +849,14 @@ export class Wallet extends BaseWallet {
     return resp;
   }
 
+  /**
+   * sendMax Send all available funds to a destination cash address
+   *
+   * @param  {string} cashaddr destination cash address
+   * @param  {SendRequestOptionsI} options Options of the send requests
+   *
+   * @returns (depending on the options parameter) the transaction id, new address balance and a link to the transaction on the blockchain explorer
+   */
   public async sendMax(
     cashaddr: string,
     options?: SendRequestOptionsI
@@ -768,7 +873,18 @@ export class Wallet extends BaseWallet {
     };
   }
 
-  private async sendMaxRaw(cashaddr: string, options?: SendRequestOptionsI) {
+  /**
+   * sendMaxRaw (internal) Send all available funds to a destination cash address
+   *
+   * @param  {string} cashaddr destination cash address
+   * @param  {SendRequestOptionsI} options Options of the send requests
+   *
+   * @returns the transaction id sent to the network
+   */
+  private async sendMaxRaw(
+    cashaddr: string,
+    options?: SendRequestOptionsI
+  ): Promise<string> {
     let maxSpendableAmount = await this.getMaxAmountToSend({
       outputCount: 1,
       options: options,
@@ -781,7 +897,129 @@ export class Wallet extends BaseWallet {
       value: maxSpendableAmount.sat,
       unit: "sat",
     });
-    return await this._processSendRequests([sendRequest], true, options);
+
+    const encodedTransaction = await this.encodeTransaction(
+      [sendRequest],
+      true,
+      options
+    );
+    const awaitTransactionPropagation =
+      !options ||
+      options.awaitTransactionPropagation === undefined ||
+      options.awaitTransactionPropagation;
+
+    const txId = await this.submitTransaction(
+      encodedTransaction,
+      awaitTransactionPropagation
+    );
+
+    return txId;
+  }
+
+  /**
+   * encodeTransaction Encode and sign a transaction given a list of sendRequests, options and estimate fees.
+   * @param  {SendRequest[]} sendRequests SendRequests
+   * @param  {boolean} discardChange=false
+   * @param  {SendRequestOptionsI} options Options of the send requests
+   */
+  public async encodeTransaction(
+    requests:
+      | SendRequest
+      | OpReturnData
+      | Array<SendRequest | OpReturnData>
+      | SendRequestArray[],
+    discardChange: boolean = false,
+    options?: SendRequestOptionsI
+  ) {
+    let sendRequests = asSendRequestObject(requests);
+
+    if (!this.privateKey) {
+      throw new Error(
+        `Wallet ${this.name} is missing either a network or private key`
+      );
+    }
+    if (!this.cashaddr) {
+      throw Error("attempted to send without a cashaddr");
+    }
+
+    if (options && options.slpAware) {
+      this._slpAware = true;
+    }
+
+    if (options && options.slpSemiAware) {
+      this._slpSemiAware = true;
+    }
+
+    // get inputs from options or query all inputs
+    let utxos: UtxoI[];
+    if (options && options.utxoIds) {
+      utxos = options.utxoIds.map((utxoId) =>
+        UtxoItem.fromId(utxoId).asElectrum()
+      );
+    } else {
+      utxos = await this.getAddressUtxos(this.cashaddr);
+    }
+
+    const bestHeight = await this.provider!.getBlockHeight()!;
+    const spendAmount = await sumSendRequestAmounts(sendRequests);
+
+    if (utxos.length === 0) {
+      throw Error("There were no Unspent Outputs");
+    }
+    if (typeof spendAmount !== "bigint") {
+      throw Error("Couldn't get spend amount when building transaction");
+    }
+
+    const relayFeePerByteInSatoshi = await getRelayFeeCache(this.provider!);
+    const feeEstimate = await getFeeAmount({
+      utxos: utxos,
+      sendRequests: sendRequests,
+      privateKey: this.privateKey,
+      relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
+      slpOutputs: [],
+    });
+
+    const fundingUtxos = await getSuitableUtxos(
+      utxos,
+      BigInt(spendAmount) + BigInt(feeEstimate),
+      bestHeight
+    );
+    if (fundingUtxos.length === 0) {
+      throw Error(
+        "The available inputs couldn't satisfy the request with fees"
+      );
+    }
+    const fee = await getFeeAmount({
+      utxos: fundingUtxos,
+      sendRequests: sendRequests,
+      privateKey: this.privateKey,
+      relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
+      slpOutputs: [],
+    });
+    const encodedTransaction = await buildEncodedTransaction(
+      fundingUtxos,
+      sendRequests,
+      this.privateKey,
+      fee,
+      discardChange
+    );
+
+    return encodedTransaction;
+  }
+
+  // Submit a raw transaction
+  public async submitTransaction(
+    transaction: Uint8Array,
+    awaitPropagation: boolean = true
+  ): Promise<string> {
+    if (!this.provider) {
+      throw Error("Wallet network provider was not initialized");
+    }
+    let rawTransaction = binToHex(transaction);
+    return await this.provider.sendRawTransaction(
+      rawTransaction,
+      awaitPropagation
+    );
   }
 
   // gets transaction history of this wallet
@@ -792,11 +1030,16 @@ export class Wallet extends BaseWallet {
   // gets last transaction of this wallet
   public async getLastTransaction(
     confirmedOnly: boolean = false
-  ): Promise<ElectrumRawTransaction> {
+  ): Promise<ElectrumRawTransaction | null> {
     let history: TxI[] = await this.getHistory();
     if (confirmedOnly) {
       history = history.filter((val) => val.height > 0);
     }
+
+    if (!history.length) {
+      return null;
+    }
+
     const [lastTx] = history.slice(-1);
     return this.provider!.getRawTransactionObject(lastTx.tx_hash);
   }
@@ -917,115 +1160,6 @@ export class Wallet extends BaseWallet {
     this.publicKeyHash = derivePublicKeyHash(this.cashaddr!);
     return this;
   }
-
-  /**
-   * _processSendRequests given a list of sendRequests, estimate fees, build the transaction and submit it.
-   * This function is an internal wrapper and may change.
-   * @param  {SendRequest[]} sendRequests SendRequests
-   * @param  {} discardChange=false
-   * @param  {SendRequestOptionsI} options Options of the send requests
-   */
-  private async _processSendRequests(
-    sendRequests: Array<SendRequest | OpReturnData>,
-    discardChange = false,
-    options?: SendRequestOptionsI
-  ) {
-    if (!this.privateKey) {
-      throw new Error(
-        `Wallet ${this.name} is missing either a network or private key`
-      );
-    }
-    if (!this.cashaddr) {
-      throw Error("attempted to send without a cashaddr");
-    }
-
-    if (options && options.slpAware) {
-      this._slpAware = true;
-    }
-
-    if (options && options.slpSemiAware) {
-      this._slpSemiAware = true;
-    }
-
-    // get inputs from options or query all inputs
-    let utxos: UtxoI[];
-    if (options && options.utxoIds) {
-      utxos = options.utxoIds.map((utxoId) =>
-        UtxoItem.fromId(utxoId).asElectrum()
-      );
-    } else {
-      utxos = await this.getAddressUtxos(this.cashaddr);
-    }
-
-    const bestHeight = await this.provider!.getBlockHeight()!;
-    const spendAmount = await sumSendRequestAmounts(sendRequests);
-
-    if (utxos.length === 0) {
-      throw Error("There were no Unspent Outputs");
-    }
-    if (typeof spendAmount !== "bigint") {
-      throw Error("Couldn't get spend amount when building transaction");
-    }
-
-    const relayFeePerByteInSatoshi = await getRelayFeeCache(this.provider!);
-    const feeEstimate = await getFeeAmount({
-      utxos: utxos,
-      sendRequests: sendRequests,
-      privateKey: this.privateKey,
-      relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
-      slpOutputs: [],
-    });
-
-    const fundingUtxos = await getSuitableUtxos(
-      utxos,
-      BigInt(spendAmount) + BigInt(feeEstimate),
-      bestHeight
-    );
-    if (fundingUtxos.length === 0) {
-      throw Error(
-        "The available inputs couldn't satisfy the request with fees"
-      );
-    }
-    const fee = await getFeeAmount({
-      utxos: fundingUtxos,
-      sendRequests: sendRequests,
-      privateKey: this.privateKey,
-      relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
-      slpOutputs: [],
-    });
-    const encodedTransaction = await buildEncodedTransaction(
-      fundingUtxos,
-      sendRequests,
-      this.privateKey,
-      fee,
-      discardChange
-    );
-
-    const awaitTransactionPropagation =
-      !options ||
-      options.awaitTransactionPropagation === undefined ||
-      options.awaitTransactionPropagation;
-
-    return await this._submitTransaction(
-      encodedTransaction,
-      awaitTransactionPropagation
-    );
-  }
-
-  // Submit a raw transaction
-  private async _submitTransaction(
-    transaction: Uint8Array,
-    awaitPropagation: boolean = true
-  ): Promise<string> {
-    if (!this.provider) {
-      throw Error("Wallet network provider was not initialized");
-    }
-    let rawTransaction = binToHex(transaction);
-    return await this.provider.sendRawTransaction(
-      rawTransaction,
-      awaitPropagation
-    );
-  }
   //#endregion Private implementation details
 
   //#region Signing

package/src/wallet/createWallet.test.ts

@@ -66,6 +66,8 @@ describe(`Named Wallets`, () => {
       isTestnet: true,
       name: "",
       network: "testnet",
+      parentDerivationPath: undefined,
+      parentXPubKey: undefined,
       privateKey: undefined,
       privateKeyWif: undefined,
       publicKey: undefined,

package/src/wallet/interface.ts

@@ -23,6 +23,7 @@ export interface WalletResponseI {
   privkey?: string;
   seed?: string;
   derivationPath?: string;
+  parentDerivationPath?: string;
 }
 
 export interface WalletInfoI {
@@ -32,6 +33,8 @@ export interface WalletInfoI {
   network: NetworkEnum;
   seed?: string;
   derivationPath?: string;
+  parentDerivationPath?: string;
+  parentXPubKey?: string;
   publicKey?: string;
   publicKeyHash?: string;
   privateKey?: string;
@@ -52,6 +55,7 @@ export interface SendRequestOptionsI {
 export interface MnemonicI {
   seed: string;
   derivationPath: string;
+  parentDerivationPath: string;
 }
 
 export interface WalletI {

package/src/wallet/model.ts

@@ -159,3 +159,25 @@ export class SendResponse {
     this.explorerUrl = explorerUrl;
   }
 }
+
+export class XPubKey {
+  path: string;
+  xPubKey: string;
+
+  constructor({ path, xPubKey }: { path: string; xPubKey: string }) {
+    this.path = path;
+    this.xPubKey = xPubKey;
+  }
+
+  public async ready() {
+    await this.xPubKey;
+    return this.asObject();
+  }
+
+  public asObject() {
+    return {
+      path: this.path,
+      xPubKey: this.xPubKey,
+    };
+  }
+}