mainnet-js 2.7.31 → 3.0.0-next.0

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 };

package/src/util/checkUtxos.ts

@@ -1,31 +1,26 @@
-import { UtxoI } from "../interface.js";
+import { Utxo, UtxoId } from "../interface.js";
 
 export async function checkUtxos(
-  utxos: UtxoI[],
-  wallet: import("../wallet/Wif.js").Wallet
-): Promise<UtxoI[]> {
-  if (utxos.some((val) => val.satoshis === 0)) {
-    const addressUtxos = await wallet.getAddressUtxos(wallet.cashaddr);
-    const absent = utxos.filter(
-      (val) =>
-        !addressUtxos.find(
-          (utxo) => val.txid === utxo.txid && val.vout === utxo.vout
-        )
-    );
-    if (absent.length) {
-      const absentString = absent
-        .map((val) => `${val.txid}:${val.vout}`)
-        .join(", ");
-      throw Error(`Utxos [${absentString}] not found in wallet`);
-    }
-
-    utxos = utxos.map(
-      (val) =>
-        addressUtxos.find(
-          (utxo) => val.txid === utxo.txid && val.vout === utxo.vout
-        )!
-    );
+  utxoIds: UtxoId[],
+  walletOrUtxos: Utxo[] | import("../wallet/Wif.js").Wallet
+): Promise<Utxo[]> {
+  const addressUtxos = Array.isArray(walletOrUtxos)
+    ? walletOrUtxos
+    : await walletOrUtxos.getUtxos();
+  const absent = utxoIds.filter(
+    (val) =>
+      !addressUtxos.find(
+        (utxo) => val.txid === utxo.txid && val.vout === utxo.vout
+      )
+  );
+  if (absent.length) {
+    const absentString = absent
+      .map((val) => `${val.txid}:${val.vout}`)
+      .join(", ");
+    throw Error(`Utxos [${absentString}] not found in wallet`);
   }
 
-  return utxos;
+  return addressUtxos.filter((val) =>
+    utxoIds.find((utxo) => val.txid === utxo.txid && val.vout === utxo.vout)
+  );
 }

package/src/util/deriveCashaddr.ts

@@ -80,6 +80,10 @@ function decodeAddress(address: string): DecodedCashAddress {
 }
 
 export function toCashaddr(address: string): string {
+  if (address.indexOf(":q") > 0 || address.indexOf(":p") > 0) {
+    return address;
+  }
+
   const result = decodeAddress(address);
 
   return encodeCashAddress({
@@ -90,6 +94,10 @@ export function toCashaddr(address: string): string {
 }
 
 export function toTokenaddr(address: string): string {
+  if (address.indexOf(":z") > 0 || address.indexOf(":r") > 0) {
+    return address;
+  }
+
   const result = decodeAddress(address);
 
   return encodeCashAddress({

package/src/util/deriveNetwork.ts

@@ -10,7 +10,7 @@ export function derivedNetwork(addresses: string[]) {
   // Get a unique set of networks requested
   let networkSet = new Set(networks);
   if (networkSet.size > 1) {
-    throw Error("Contract addresses are not on the same network");
+    throw Error("Addresses are not on the same network");
   } else if (networkSet.size === 0) {
     throw Error("No address network was derived");
   } else {

package/src/util/derivePublicKeyHash.test.ts

@@ -53,16 +53,3 @@ test("Should calculate public key hash consistent with hash160", async () => {
   expect(binToHex(pkh2)).toEqual("d986ed01b7a22225a70edbf2ba7cfb63a15cb3aa");
   expect(binToHex(pkh3)).toEqual("d986ed01b7a22225a70edbf2ba7cfb63a15cb3aa");
 });
-
-test("Should return the a public key hash of manually set wallet", async () => {
-  let w = new Wallet();
-  // @ts-ignore
-  w.privateKey = hexToBin(
-    "e284129cc0922579a535bbf4d1a3b25773090d28c909bc0fed73b5e0222cc372"
-  );
-  // @ts-ignore
-  await w.deriveInfo();
-  let pkh = derivePublicKeyHash(w.getDepositAddress());
-  let expectedPKH = "d986ed01b7a22225a70edbf2ba7cfb63a15cb3aa";
-  expect(binToHex(pkh)).toBe(expectedPKH);
-});

package/src/util/hd.ts

@@ -0,0 +1,16 @@
+export const arrayRange = (start: number, stop: number) =>
+  Array.from({ length: stop - start }, (_, index) => start + index);
+
+export const getNextUnusedIndex = (
+  index: number,
+  statuses: Array<string | null>
+): number => {
+  if (index === -1) {
+    index = statuses.findIndex((status) => status === null);
+    if (index === -1) {
+      index = statuses.length;
+    }
+  }
+
+  return index;
+};

package/src/util/index.ts

@@ -35,3 +35,4 @@ export {
 } from "./balanceObjectFromSatoshi.js";
 export * from "./sumUtxoValue.js";
 export { decodeHeader } from "./header.js";
+export * from "./checkUtxos.js";

package/src/util/sumUtxoValue.ts

@@ -1,8 +1,8 @@
-import { UtxoI } from "../interface.js";
+import { Utxo } from "../interface.js";
 
-export function sumUtxoValue(utxos: UtxoI[]) {
+export function sumUtxoValue(utxos: Utxo[]) {
   if (utxos.length > 0) {
-    const balanceArray: number[] = utxos.map((o: UtxoI) => {
+    const balanceArray: number[] = utxos.map((o: Utxo) => {
       return o.satoshis;
     });
     const balance = balanceArray.reduce((a: number, b: number) => a + b, 0);
@@ -12,11 +12,11 @@ export function sumUtxoValue(utxos: UtxoI[]) {
   }
 }
 
-export function sumTokenAmounts(utxos: UtxoI[], tokenId: string): bigint {
+export function sumTokenAmounts(utxos: Utxo[], tokenId: string): bigint {
   if (utxos.length > 0) {
     const tokenArray: bigint[] = utxos
       .filter((utxo) => utxo.token?.tokenId === tokenId)
-      .map((o: UtxoI) => {
+      .map((o: Utxo) => {
         return o.token?.amount || 0n;
       });
     const balance = tokenArray.reduce((a: bigint, b: bigint) => a + b, 0n);