mainnet-js 2.7.33 → 3.0.0-next.0

package/src/message/signed.test.ts

@@ -1,6 +1,6 @@
 import { SignedMessage, hash_message } from "./signed.js";
 import { Wallet, RegTestWallet, TestNetWallet } from "../wallet/Wif.js";
-import { binToBase64, binToHex } from "@bitauth/libauth";
+import { binToHex } from "@bitauth/libauth";
 
 import fs from "fs";
 
@@ -14,13 +14,13 @@ describe("Test message Signing and Verification", () => {
     // Test that the double sha256 hash of the wrapped messages matches
     // what would be had internally in electron-cash
     // b'\x18Bitcoin Signed Message:\n' + b'{message.length}' + b'{message}'
-    let test_hash = await hash_message("test");
+    let test_hash = hash_message("test");
     expect(binToHex(test_hash)).toBe(
       "9ce428d58e8e4caf619dc6fc7b2c2c28f0561654d1f80f322c038ad5e67ff8a6"
     );
 
     // b'\xe6\xb5\x8b\xe8\xaf\x95' in binary python
-    let 测试_hash = await hash_message("测试");
+    let 测试_hash = hash_message("测试");
     expect(binToHex(测试_hash)).toBe(
       "8d8405050b7a763ccd5683f8470ea7dcbd10a87da2b7fe07eb2679ba71229688"
     );
@@ -34,12 +34,12 @@ describe("Test message Signing and Verification", () => {
     expect(w1.cashaddr!).toBe(
       "bitcoincash:qqehccy89v7ftlfgr9v0zvhjzyy7eatdkqt05lt3nw"
     );
-    let sig = await SignedMessage.sign(msg1, w1.privateKey!);
+    let sig = SignedMessage.sign(msg1, w1.privateKey!);
 
     let coreLibSig =
       "H/9jMOnj4MFbH3d7t4yCQ9i7DgZU/VZ278w3+ySv2F4yIsdqjsc5ng3kmN8OZAThgyfCZOQxZCWza9V5XzlVY0Y=";
     expect(sig.signature).toBe(coreLibSig);
-    let result = await SignedMessage.verify(msg1, sig.signature, w1.cashaddr!);
+    let result = SignedMessage.verify(msg1, sig.signature, w1.cashaddr!);
     expect(result.valid).toBe(true);
     expect(result.details!.messageHash).toBe(
       "gE9BDBFAOqW+yoOzABjnM+LQRWHd4dvUVrsTR+sIWsU="
@@ -50,7 +50,7 @@ describe("Test message Signing and Verification", () => {
     expect(result.details!.signatureType).toBe("recoverable");
 
     let msg2 = "Lessons for China from Japan’s lost decade";
-    result = await SignedMessage.verify(msg2, sig.signature, w1.cashaddr!);
+    result = SignedMessage.verify(msg2, sig.signature, w1.cashaddr!);
     expect(result.valid).toBe(false);
     expect(result.details!.messageHash).toBe(
       "070kQIcYPSHApGdOGH0O81N1AkMbNKwCTM3IX2Svd3I="
@@ -73,11 +73,11 @@ describe("Test message Signing and Verification", () => {
       "bchtest:qqf25s9nm4uq982t94vq75v78n4j0e4r4vdf9j48wn"
     );
     let msg = "test";
-    let sig = await SignedMessage.sign(msg, w.privateKey!);
-    let result = await SignedMessage.verify(msg, sig.signature, w.cashaddr!);
+    let sig = SignedMessage.sign(msg, w.privateKey!);
+    let result = SignedMessage.verify(msg, sig.signature, w.cashaddr!);
     expect(result.valid).toBe(true);
 
-    result = await SignedMessage.verify("test2", sig.signature, w.cashaddr!);
+    result = SignedMessage.verify("test2", sig.signature, w.cashaddr!);
     expect(result.valid).toBe(false);
   });
 
@@ -86,12 +86,12 @@ describe("Test message Signing and Verification", () => {
       "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
     );
     let msg = "test";
-    let sig = await SignedMessage.sign(msg, w.privateKey!);
+    let sig = SignedMessage.sign(msg, w.privateKey!);
 
-    let result = await SignedMessage.verify(msg, sig.signature, w.cashaddr!);
+    let result = SignedMessage.verify(msg, sig.signature, w.cashaddr!);
     expect(result.valid).toBe(true);
 
-    result = await SignedMessage.verify("test2", sig.signature, w.cashaddr!);
+    result = SignedMessage.verify("test2", sig.signature, w.cashaddr!);
     expect(result.valid).toBe(false);
   });
 
@@ -100,11 +100,11 @@ describe("Test message Signing and Verification", () => {
       "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
     );
     let msg = "测试";
-    let sig = await SignedMessage.sign(msg, w.privateKey!);
-    let result = await SignedMessage.verify(msg, sig.signature, w.cashaddr!);
+    let sig = SignedMessage.sign(msg, w.privateKey!);
+    let result = SignedMessage.verify(msg, sig.signature, w.cashaddr!);
     expect(result.valid).toBe(true);
 
-    result = await SignedMessage.verify("测试二", sig.signature, w.cashaddr!);
+    result = SignedMessage.verify("测试二", sig.signature, w.cashaddr!);
     expect(result.valid).toBe(false);
   });
 
@@ -113,8 +113,8 @@ describe("Test message Signing and Verification", () => {
       "wif:mainnet:L1TnU2zbNaAqMoVh65Cyvmcjzbrj41Gs9iTLcWbpJCMynXuap6UN"
     );
     let msg = "test";
-    let sig = await SignedMessage.sign(msg, w.privateKey!);
-    let result = await SignedMessage.verify(
+    let sig = SignedMessage.sign(msg, w.privateKey!);
+    let result = SignedMessage.verify(
       msg,
       sig.raw!.schnorr,
       undefined,
@@ -125,7 +125,7 @@ describe("Test message Signing and Verification", () => {
 
     let msg2 =
       "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
-    let invalid = await SignedMessage.verify(
+    let invalid = SignedMessage.verify(
       msg2,
       sig.raw!.schnorr,
       undefined,
@@ -139,8 +139,8 @@ describe("Test message Signing and Verification", () => {
       "wif:mainnet:L1TnU2zbNaAqMoVh65Cyvmcjzbrj41Gs9iTLcWbpJCMynXuap6UN"
     );
     let msg = "test";
-    let sig = await SignedMessage.sign(msg, w.privateKey!);
-    let result = await SignedMessage.verify(
+    let sig = SignedMessage.sign(msg, w.privateKey!);
+    let result = SignedMessage.verify(
       msg,
       sig.raw!.der,
       undefined,
@@ -155,8 +155,8 @@ describe("Test message Signing and Verification", () => {
       "wif:mainnet:L1TnU2zbNaAqMoVh65Cyvmcjzbrj41Gs9iTLcWbpJCMynXuap6UN"
     );
     let msg = "test";
-    let sig = await SignedMessage.sign(msg, w.privateKey!);
-    let result = await SignedMessage.verify(
+    let sig = SignedMessage.sign(msg, w.privateKey!);
+    let result = SignedMessage.verify(
       msg,
       sig.raw!.ecdsa,
       undefined,
@@ -167,7 +167,7 @@ describe("Test message Signing and Verification", () => {
 
     let msg2 =
       "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
-    let invalid = await SignedMessage.verify(
+    let invalid = SignedMessage.verify(
       msg2,
       sig.raw!.ecdsa,
       undefined,
@@ -181,8 +181,8 @@ describe("Test message Signing and Verification", () => {
       "wif:mainnet:L1TnU2zbNaAqMoVh65Cyvmcjzbrj41Gs9iTLcWbpJCMynXuap6UN"
     );
     let msg = await loadLargeMessage();
-    let sig = await SignedMessage.sign(msg, w.privateKey!);
-    let result = await SignedMessage.verify(msg, sig.signature, w.cashaddr!);
+    let sig = SignedMessage.sign(msg, w.privateKey!);
+    let result = SignedMessage.verify(msg, sig.signature, w.cashaddr!);
     expect(result.valid).toBe(true);
   });
 
@@ -194,21 +194,13 @@ describe("Test message Signing and Verification", () => {
     expect(w1.cashaddr!).toBe(
       "bitcoincash:qqehccy89v7ftlfgr9v0zvhjzyy7eatdkqt05lt3nw"
     );
-    let sig = await Wallet.signedMessage.sign(msg1, w1.privateKey!);
-    let result = await Wallet.signedMessage.verify(
-      msg1,
-      sig.signature,
-      w1.cashaddr!
-    );
+    let sig = SignedMessage.sign(msg1, w1.privateKey!);
+    let result = SignedMessage.verify(msg1, sig.signature, w1.cashaddr!);
     expect(result.valid).toBe(true);
 
     let msg2 =
       "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
-    let invalid = await Wallet.signedMessage.verify(
-      msg2,
-      sig.signature,
-      w1.cashaddr!
-    );
+    let invalid = SignedMessage.verify(msg2, sig.signature, w1.cashaddr!);
     expect(invalid.valid).toBe(false);
   });
 
@@ -221,13 +213,13 @@ describe("Test message Signing and Verification", () => {
     expect(w1.cashaddr!).toBe(
       "bitcoincash:qqehccy89v7ftlfgr9v0zvhjzyy7eatdkqt05lt3nw"
     );
-    let sig = await w1.sign(msg1);
-    let result = await w1.verify(msg1, sig.signature);
+    let sig = w1.sign(msg1);
+    let result = w1.verify(msg1, sig.signature);
     expect(result.valid).toBe(true);
 
     let msg2 =
       "Biggest Selloff in 25 Years Hits Japan Bonds as BOJ Loosens Grip";
-    let invalid = await w1.verify(msg2, sig.signature);
+    let invalid = w1.verify(msg2, sig.signature);
     expect(invalid.valid).toBe(false);
   });
 
@@ -244,14 +236,14 @@ describe("Test message Signing and Verification", () => {
     expect(w1.cashaddr!).toBe(
       "bitcoincash:qqad5sy4jml3f6vcp246dulsex04xp48wq23d35rqe"
     );
-    let result = await w1.verify(beak, beakSig);
+    let result = w1.verify(beak, beakSig);
     expect(result.valid).toBe(true);
     expect(result.details?.publicKeyHashMatch).toBe(true);
     expect(result.details?.publicKeyMatch).toBe(false);
     expect(result.details?.signatureValid).toBe(true);
     expect(result.details?.signatureType).toBe("recoverable");
 
-    let badResult = await w1.verify(falseMessage, beakSig);
+    let badResult = w1.verify(falseMessage, beakSig);
     expect(badResult.valid).toBe(false);
 
     // While the recoverable sig is valid, it doesn't match the message.
@@ -289,12 +281,12 @@ describe("Test message Signing and Verification", () => {
     expect(w1.cashaddr!).toBe(
       "bitcoincash:qqehccy89v7ftlfgr9v0zvhjzyy7eatdkqt05lt3nw"
     );
-    let sig = await SignedMessage.sign(msg1, w1.privateKey!);
+    let sig = SignedMessage.sign(msg1, w1.privateKey!);
 
     let coreLibSig =
       "H/9jMOnj4MFbH3d7t4yCQ9i7DgZU/VZ278w3+ySv2F4yIsdqjsc5ng3kmN8OZAThgyfCZOQxZCWza9V5XzlVY0Y=";
     expect(sig.signature).toBe(coreLibSig);
-    let result = await SignedMessage.verify(msg1, sig.signature, w1.cashaddr!);
+    let result = SignedMessage.verify(msg1, sig.signature, w1.cashaddr!);
     expect(result.valid).toBe(true);
     expect(result.details!.messageHash).toBe(
       "gE9BDBFAOqW+yoOzABjnM+LQRWHd4dvUVrsTR+sIWsU="
@@ -304,11 +296,7 @@ describe("Test message Signing and Verification", () => {
     expect(result.details!.signatureValid).toBe(true);
     expect(result.details!.signatureType).toBe("recoverable");
 
-    let result2 = await SignedMessage.verify(
-      msg1,
-      sig.signature,
-      w1.tokenaddr!
-    );
+    let result2 = SignedMessage.verify(msg1, sig.signature, w1.tokenaddr!);
     expect(result2.valid).toBe(true);
     expect(result2.details!.messageHash).toBe(
       "gE9BDBFAOqW+yoOzABjnM+LQRWHd4dvUVrsTR+sIWsU="

package/src/message/signed.ts

@@ -46,7 +46,7 @@ function message_magic(str: string) {
  *
  * @returns a promise to the hash of the string.
  */
-export async function hash_message(str: string) {
+export function hash_message(str: string) {
   const h = sha256.hash;
   return h(h(message_magic(str)));
 }
@@ -60,11 +60,8 @@ export class SignedMessage implements SignedMessageI {
    *
    * @returns a promise to signature as a string
    */
-  public async sign(
-    message: string,
-    privateKey: Uint8Array
-  ): Promise<SignedMessageResponseI> {
-    const messageHash = await hash_message(message);
+  public sign(message: string, privateKey: Uint8Array): SignedMessageResponseI {
+    const messageHash = hash_message(message);
     const rs = secp256k1.signMessageHashRecoverableCompact(
       privateKey,
       messageHash
@@ -99,7 +96,7 @@ export class SignedMessage implements SignedMessageI {
     };
   }
 
-  public static async sign(message: string, privateKey: Uint8Array) {
+  public static sign(message: string, privateKey: Uint8Array) {
     return new this().sign(message, privateKey);
   }
   /**
@@ -112,14 +109,14 @@ export class SignedMessage implements SignedMessageI {
    *
    * @returns a promise to signature as a string
    */
-  public async verify(
+  public verify(
     message: string,
     signature: string,
     cashaddr?: string,
     publicKey?: Uint8Array
-  ): Promise<VerifyMessageResponseI> {
+  ): VerifyMessageResponseI {
     // Check that the signature is valid for the given message.
-    const messageHash = await hash_message(message);
+    const messageHash = hash_message(message);
     const sig = base64ToBin(signature);
 
     let signatureValid = false;
@@ -139,7 +136,7 @@ export class SignedMessage implements SignedMessageI {
         throw new Error(recoveredPk);
       }
 
-      pkh = await hash160(recoveredPk);
+      pkh = hash160(recoveredPk);
       signatureType = "recoverable";
       signatureValid = secp256k1.verifySignatureCompact(
         rawSig,
@@ -193,7 +190,7 @@ export class SignedMessage implements SignedMessageI {
     };
   }
 
-  public static async verify(
+  public static verify(
     message: string,
     signature: string,
     cashaddr?: string,

package/src/network/ElectrumNetworkProvider.ts

@@ -9,12 +9,11 @@ import { default as NetworkProvider } from "./NetworkProvider.js";
 import {
   HexHeaderI,
   TxI,
-  UtxoI,
+  Utxo,
   ElectrumBalanceI,
   HeaderI,
 } from "../interface.js";
 import { Network } from "../interface.js";
-import { delay } from "../util/delay.js";
 import { ElectrumRawTransaction, ElectrumUtxo } from "./interface.js";
 
 import { CancelFn } from "../wallet/interface.js";
@@ -45,7 +44,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     }
 
     if (Config.UseMemoryCache && !(this._cache instanceof MemoryCache)) {
-      this._cache = new IndexedDbCache();
+      this._cache = new MemoryCache();
       return this._cache;
     }
 
@@ -77,13 +76,14 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     }
   }
 
-  async getUtxos(cashaddr: string): Promise<UtxoI[]> {
+  async getUtxos(cashaddr: string): Promise<Utxo[]> {
     const result = await this.performRequest<ElectrumUtxo[]>(
       "blockchain.address.listunspent",
       cashaddr,
       "include_tokens"
     );
     return result.map((utxo) => ({
+      address: cashaddr,
       txid: utxo.tx_hash,
       vout: utxo.tx_pos,
       satoshis: utxo.value,

package/src/network/NetworkProvider.ts

@@ -1,4 +1,4 @@
-import { TxI, UtxoI, Network, HexHeaderI, HeaderI } from "../interface.js";
+import { TxI, Utxo, Network, HexHeaderI, HeaderI } from "../interface.js";
 import { CancelFn } from "../wallet/interface.js";
 
 export default interface NetworkProvider {
@@ -12,7 +12,7 @@ export default interface NetworkProvider {
    * @param cashaddr The CashAddress for which we wish to retrieve UTXOs.
    * @returns List of UTXOs spendable by the provided address.
    */
-  getUtxos(cashaddr: string): Promise<UtxoI[]>;
+  getUtxos(cashaddr: string): Promise<Utxo[]>;
 
   /**
    * Retrieve all balance of an address in satoshi

package/src/network/Rpc.test.ts

@@ -1,8 +1,8 @@
 import { disconnectProviders, initProviders } from "./Connection";
 import { RegTestWallet } from "../wallet/Wif";
 import { getNetworkProvider } from "../network/default";
-import { Network } from "cashscript";
 import { mine } from "../mine";
+import { Network } from "../interface";
 
 const aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
 

package/src/network/constant.ts

@@ -7,8 +7,8 @@ export const networkTickerMap = {
 };
 
 export const mainnetServers = [
-  "wss://bch.imaginary.cash:50004",
-  //"wss://blackie.c3-soft.com:50004",
+  // "wss://bch.imaginary.cash:50004",
+  "wss://blackie.c3-soft.com:50004",
   // "wss://electrum.imaginary.cash:50004",
   // "wss://fulcrum.fountainhead.cash",
 ];
@@ -29,9 +29,9 @@ export const mainnetServers = [
 
 // chipnet
 export const testnetServers = [
-  // "wss://chipnet.imaginary.cash:50004",
+  "wss://chipnet.imaginary.cash:50004",
   //"wss://blackie.c3-soft.com:64004", // chipnet with protocol 1.5.0
-  "wss://chipnet.bch.ninja:50004",
+  // "wss://chipnet.bch.ninja:50004",
 ];
 
 export const regtestServers = ["ws://127.0.0.1:60003"];

package/src/transaction/Wif.ts

@@ -1,6 +1,5 @@
 import {
   walletTemplateP2pkhNonHd,
-  walletTemplateToCompilerBCH,
   cashAddressToLockingBytecode,
   Compiler,
   encodeTransaction,
@@ -8,14 +7,15 @@ import {
   importWalletTemplate,
   AnyCompilerConfiguration,
   AuthenticationProgramStateCommon,
-  CompilationContextBCH,
   Output,
   hexToBin,
   verifyTransactionTokens,
   decodeTransaction,
   TransactionTemplateFixed,
+  CompilationContextBch,
+  walletTemplateToCompilerBch,
 } from "@bitauth/libauth";
-import { NFTCapability, TokenI, UtxoI } from "../interface.js";
+import { NFTCapability, TokenI, Utxo } from "../interface.js";
 import { allocateFee } from "./allocateFee.js";
 
 import { DUST_UTXO_THRESHOLD } from "../constant.js";
@@ -30,26 +30,31 @@ import { amountInSatoshi } from "../util/amountInSatoshi.js";
 import { sumSendRequestAmounts } from "../util/sumSendRequestAmounts.js";
 import { sumUtxoValue } from "../util/sumUtxoValue.js";
 import { FeePaidByEnum } from "../wallet/enum.js";
+import { WalletCacheI } from "../cache/walletCache.js";
+
+export const placeholderPrivateKey =
+  "0000000000000000000000000000000000000000000000000000000000000001";
+export const placeholderPrivateKeyBin = hexToBin(placeholderPrivateKey);
 
 // Build a transaction for a p2pkh transaction for a non HD wallet
 export async function buildP2pkhNonHdTransaction({
   inputs,
   outputs,
   signingKey,
-  sourceAddress,
   fee = 0,
   discardChange = false,
   feePaidBy = FeePaidByEnum.change,
   changeAddress = "",
+  walletCache,
 }: {
-  inputs: UtxoI[];
+  inputs: Utxo[];
   outputs: Array<SendRequest | TokenSendRequest | OpReturnData>;
-  signingKey: Uint8Array;
-  sourceAddress: string;
+  signingKey?: Uint8Array;
   fee?: number;
   discardChange?: boolean;
   feePaidBy?: FeePaidByEnum;
   changeAddress?: string;
+  walletCache?: WalletCacheI;
 }) {
   if (!signingKey) {
     throw new Error("Missing signing key when building transaction");
@@ -60,8 +65,8 @@ export async function buildP2pkhNonHdTransaction({
     throw new Error("Transaction template error");
   }
 
-  const compiler = await walletTemplateToCompilerBCH(template);
-  const inputAmount = await sumUtxoValue(inputs);
+  const compiler = walletTemplateToCompilerBch(template);
+  const inputAmount = sumUtxoValue(inputs);
 
   const sendAmount = await sumSendRequestAmounts(outputs);
 
@@ -72,7 +77,7 @@ export async function buildP2pkhNonHdTransaction({
   const lockedOutputs = await prepareOutputs(outputs);
 
   if (!changeAddress) {
-    changeAddress = sourceAddress;
+    changeAddress = inputs[0].address;
   }
 
   if (discardChange !== true) {
@@ -92,7 +97,7 @@ export async function buildP2pkhNonHdTransaction({
     inputs,
     compiler,
     signingKey,
-    sourceAddress,
+    walletCache,
   });
   const result = generateTransaction({
     inputs: preparedInputs,
@@ -121,16 +126,16 @@ export function prepareInputs({
   inputs,
   compiler,
   signingKey,
-  sourceAddress,
+  walletCache,
 }: {
-  inputs: UtxoI[];
+  inputs: Utxo[];
   compiler: Compiler<
-    CompilationContextBCH,
-    AnyCompilerConfiguration<CompilationContextBCH>,
+    CompilationContextBch,
+    AnyCompilerConfiguration<CompilationContextBch>,
     AuthenticationProgramStateCommon
   >;
   signingKey: Uint8Array;
-  sourceAddress: string;
+  walletCache?: WalletCacheI;
 }) {
   const preparedInputs: any[] = [];
   const sourceOutputs: any[] = [];
@@ -160,7 +165,9 @@ export function prepareInputs({
             }
           : undefined,
     };
-    const key = signingKey?.length ? signingKey : Uint8Array.from(Array(32));
+    const key =
+      walletCache?.getByAddress(i.address)?.privateKey ??
+      (signingKey?.length ? signingKey : Uint8Array.from(Array(32)));
     const newInput = {
       outpointIndex: utxoIndex,
       outpointTransactionHash: utxoOutpointTransactionHash,
@@ -178,7 +185,7 @@ export function prepareInputs({
 
     preparedInputs.push(newInput);
 
-    const lockingBytecode = cashAddressToLockingBytecode(sourceAddress);
+    const lockingBytecode = cashAddressToLockingBytecode(i.address);
     if (typeof lockingBytecode === "string") {
       throw lockingBytecode;
     }
@@ -292,22 +299,22 @@ export function prepareTokenOutputs(request: TokenSendRequest): Output {
  * @returns A promise to a list of unspent outputs
  */
 export async function getSuitableUtxos(
-  inputs: UtxoI[],
+  inputs: Utxo[],
   amountRequired: bigint | undefined,
   bestHeight: number,
   feePaidBy: FeePaidByEnum,
   requests: SendRequestType[],
-  ensureUtxos: UtxoI[] = [],
+  ensureUtxos: Utxo[] = [],
   tokenOperation: "send" | "genesis" | "mint" | "burn" = "send"
-): Promise<UtxoI[]> {
-  const suitableUtxos: UtxoI[] = [...ensureUtxos];
+): Promise<Utxo[]> {
+  const suitableUtxos: Utxo[] = [...ensureUtxos];
   let amountAvailable = BigInt(0);
   const tokenRequests = requests.filter(
     (val) => val instanceof TokenSendRequest
   ) as TokenSendRequest[];
 
   const availableInputs = inputs.slice();
-  const selectedInputs: UtxoI[] = [];
+  const selectedInputs: Utxo[] = [];
 
   // find matching utxos for token transfers
   if (tokenOperation === "send") {
@@ -438,9 +445,8 @@ export async function getFeeAmountSimple({
   relayFeePerByteInSatoshi,
   discardChange,
 }: {
-  utxos: UtxoI[];
+  utxos: Utxo[];
   sendRequests: Array<SendRequest | TokenSendRequest | OpReturnData>;
-  privateKey: Uint8Array;
   sourceAddress: string;
   relayFeePerByteInSatoshi: number;
   feePaidBy: FeePaidByEnum;
@@ -494,19 +500,19 @@ export async function getFeeAmountSimple({
 export async function getFeeAmount({
   utxos,
   sendRequests,
-  privateKey,
   sourceAddress,
   relayFeePerByteInSatoshi,
   feePaidBy,
   discardChange,
+  walletCache,
 }: {
-  utxos: UtxoI[];
+  utxos: Utxo[];
   sendRequests: Array<SendRequest | TokenSendRequest | OpReturnData>;
-  privateKey: Uint8Array;
   sourceAddress: string;
   relayFeePerByteInSatoshi: number;
   feePaidBy: FeePaidByEnum;
   discardChange?: boolean;
+  walletCache?: WalletCacheI;
 }) {
   // build transaction
   if (utxos) {
@@ -515,12 +521,12 @@ export async function getFeeAmount({
       await buildEncodedTransaction({
         inputs: utxos,
         outputs: sendRequests,
-        signingKey: privateKey,
-        sourceAddress,
+        signingKey: placeholderPrivateKeyBin,
         fee: 0, //DUST_UTXO_THRESHOLD
         discardChange: discardChange ?? false,
         feePaidBy,
         changeAddress: "",
+        walletCache,
       });
 
     return Math.ceil(draftTransaction.length * relayFeePerByteInSatoshi + 1);
@@ -536,32 +542,32 @@ export async function buildEncodedTransaction({
   inputs,
   outputs,
   signingKey,
-  sourceAddress,
   fee = 0,
   discardChange = false,
   feePaidBy = FeePaidByEnum.change,
   changeAddress = "",
   buildUnsigned = false,
+  walletCache,
 }: {
-  inputs: UtxoI[];
+  inputs: Utxo[];
   outputs: Array<SendRequest | TokenSendRequest | OpReturnData>;
   signingKey: Uint8Array;
-  sourceAddress: string;
   fee?: number;
   discardChange?: boolean;
   feePaidBy?: FeePaidByEnum;
   changeAddress?: string;
   buildUnsigned?: boolean;
+  walletCache?: WalletCacheI;
 }) {
   const { transaction, sourceOutputs } = await buildP2pkhNonHdTransaction({
     inputs,
     outputs,
     signingKey,
-    sourceAddress,
     fee,
     discardChange,
     feePaidBy,
     changeAddress,
+    walletCache,
   });
 
   if (buildUnsigned === true) {
@@ -592,7 +598,7 @@ export async function signUnsignedTransaction(
     throw new Error("Transaction template error");
   }
 
-  const compiler = walletTemplateToCompilerBCH(template);
+  const compiler = walletTemplateToCompilerBch(template);
   const transactionTemplate: Readonly<
     TransactionTemplateFixed<typeof compiler>
   > = { ...decoded };