mainnet-js 1.1.0 → 1.1.2

package/src/wallet/Wif.test.ts

@@ -7,7 +7,13 @@ import { DERIVATION_PATHS, DUST_UTXO_THRESHOLD as DUST } from "../constant";
 import { delay } from "../util/delay";
 import { OpReturnData, SendResponse } from "./model";
 import { ElectrumRawTransaction } from "../network/interface";
-import { binToHex, hexToBin, utf8ToBin } from "@bitauth/libauth";
+import {
+  binToHex,
+  binsAreEqual,
+  decodeTransaction,
+  hexToBin,
+  utf8ToBin,
+} from "@bitauth/libauth";
 import { mine } from "../mine";
 import ElectrumNetworkProvider from "../network/ElectrumNetworkProvider";
 
@@ -1114,4 +1120,98 @@ describe(`Wallet extrema behavior regression testing`, () => {
       (await bob.getMaxAmountToSend({ options: { slpSemiAware: false } })).sat
     ).toBeLessThanOrEqual(546);
   });
+
+  test("Should encode unsigned transactions", async () => {
+    const aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
+    const aliceWallet = await RegTestWallet.fromId(aliceWif);
+    const bobWallet = await RegTestWallet.newRandom();
+    aliceWallet.privateKey = undefined;
+
+    const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+    {
+      const { encodedTransaction, sourceOutputs } =
+        await aliceWallet.encodeTransaction(
+          [
+            {
+              cashaddr: bobWallet.cashaddr!,
+              value: 2000,
+              unit: "satoshis",
+            },
+          ],
+          false,
+          { buildUnsigned: true }
+        );
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs.length).toBe(decoded.inputs.length);
+    }
+
+    {
+      const { unsignedTransaction, sourceOutputs } = await aliceWallet.send(
+        [
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 2000,
+            unit: "satoshis",
+          },
+        ],
+        { buildUnsigned: true }
+      );
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+    }
+
+    {
+      const { unsignedTransaction, sourceOutputs } = await aliceWallet.sendMax(
+        bobWallet.cashaddr!,
+        { buildUnsigned: true }
+      );
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+    }
+  });
 });

package/src/wallet/Wif.ts

@@ -849,7 +849,7 @@ export class Wallet extends BaseWallet {
       options: {},
     }
   ): Promise<{ value: number; utxos: UtxoI[] }> {
-    if (!this.privateKey) {
+    if (!this.privateKey && params.options?.buildUnsigned !== true) {
       throw Error("Couldn't get network or private key for wallet.");
     }
     if (!this.cashaddr) {
@@ -907,7 +907,8 @@ export class Wallet extends BaseWallet {
     const fee = await getFeeAmount({
       utxos: fundingUtxos,
       sendRequests: sendRequests,
-      privateKey: this.privateKey,
+      privateKey: this.privateKey ?? Uint8Array.from([]),
+      sourceAddress: this.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       slpOutputs: [],
       feePaidBy: feePaidBy,
@@ -953,31 +954,33 @@ export class Wallet extends BaseWallet {
       | SendRequestArray[],
     options?: SendRequestOptionsI
   ): Promise<SendResponse> {
-    let { encodedTransaction, tokenIds } = await this.encodeTransaction(
-      requests,
-      undefined,
-      options
-    );
+    const { encodedTransaction, tokenIds, sourceOutputs } =
+      await this.encodeTransaction(requests, undefined, options);
 
-    const awaitTransactionPropagation =
-      !options ||
-      options.awaitTransactionPropagation === undefined ||
-      options.awaitTransactionPropagation;
+    const resp = new SendResponse({});
+    resp.tokenIds = tokenIds;
 
-    const txId = await this.submitTransaction(
-      encodedTransaction,
-      awaitTransactionPropagation
-    );
+    if (options?.buildUnsigned !== true) {
+      const txId = await this.submitTransaction(
+        encodedTransaction,
+        options?.awaitTransactionPropagation === undefined ||
+          options?.awaitTransactionPropagation === true
+      );
 
-    let resp = new SendResponse({});
-    resp.txId = txId;
-    const queryBalance =
-      !options || options.queryBalance === undefined || options.queryBalance;
-    if (queryBalance) {
-      resp.balance = (await this.getBalance()) as BalanceResponse;
+      resp.txId = txId;
+      resp.explorerUrl = this.explorerUrl(resp.txId);
+
+      if (
+        options?.queryBalance === undefined ||
+        options?.queryBalance === true
+      ) {
+        resp.balance = (await this.getBalance()) as BalanceResponse;
+      }
+    } else {
+      resp.unsignedTransaction = binToHex(encodedTransaction);
+      resp.sourceOutputs = sourceOutputs;
     }
-    resp.explorerUrl = this.explorerUrl(resp.txId);
-    resp.tokenIds = tokenIds;
+
     return resp;
   }
 
@@ -993,16 +996,7 @@ export class Wallet extends BaseWallet {
     cashaddr: string,
     options?: SendRequestOptionsI
   ): Promise<SendResponse> {
-    const txId = await this.sendMaxRaw(cashaddr, options);
-    const queryBalance =
-      !options || options.queryBalance === undefined || options.queryBalance;
-    return {
-      txId: txId,
-      balance: queryBalance
-        ? ((await this.getBalance()) as BalanceResponse)
-        : undefined,
-      explorerUrl: this.explorerUrl(txId),
-    };
+    return await this.sendMaxRaw(cashaddr, options);
   }
 
   /**
@@ -1016,11 +1010,13 @@ export class Wallet extends BaseWallet {
   private async sendMaxRaw(
     cashaddr: string,
     options?: SendRequestOptionsI
-  ): Promise<string> {
-    let { value: maxSpendableAmount, utxos } = await this._getMaxAmountToSend({
-      outputCount: 1,
-      options: options,
-    });
+  ): Promise<SendResponse> {
+    const { value: maxSpendableAmount, utxos } = await this._getMaxAmountToSend(
+      {
+        outputCount: 1,
+        options: options,
+      }
+    );
 
     if (!options) {
       options = {};
@@ -1028,28 +1024,40 @@ export class Wallet extends BaseWallet {
 
     options.utxoIds = utxos;
 
-    let sendRequest = new SendRequest({
+    const sendRequest = new SendRequest({
       cashaddr: cashaddr,
       value: maxSpendableAmount,
       unit: "sat",
     });
 
-    const { encodedTransaction } = await this.encodeTransaction(
-      [sendRequest],
-      true,
-      options
-    );
-    const awaitTransactionPropagation =
-      !options ||
-      options.awaitTransactionPropagation === undefined ||
-      options.awaitTransactionPropagation;
-
-    const txId = await this.submitTransaction(
-      encodedTransaction,
-      awaitTransactionPropagation
-    );
+    const { encodedTransaction, tokenIds, sourceOutputs } =
+      await this.encodeTransaction([sendRequest], true, options);
+
+    const resp = new SendResponse({});
+    resp.tokenIds = tokenIds;
+
+    if (options?.buildUnsigned !== true) {
+      const txId = await this.submitTransaction(
+        encodedTransaction,
+        options?.awaitTransactionPropagation === undefined ||
+          options?.awaitTransactionPropagation === true
+      );
+
+      resp.txId = txId;
+      resp.explorerUrl = this.explorerUrl(resp.txId);
 
-    return txId;
+      if (
+        options?.queryBalance === undefined ||
+        options?.queryBalance === true
+      ) {
+        resp.balance = (await this.getBalance()) as BalanceResponse;
+      }
+    } else {
+      resp.unsignedTransaction = binToHex(encodedTransaction);
+      resp.sourceOutputs = sourceOutputs;
+    }
+
+    return resp;
   }
 
   /**
@@ -1070,7 +1078,7 @@ export class Wallet extends BaseWallet {
   ) {
     let sendRequests = asSendRequestObject(requests);
 
-    if (!this.privateKey) {
+    if (!this.privateKey && options?.buildUnsigned !== true) {
       throw new Error(
         `Wallet ${this.name} is missing either a network or private key`
       );
@@ -1124,6 +1132,13 @@ export class Wallet extends BaseWallet {
       utxos = utxos.filter((val) => !val.token);
     }
 
+    // let tokenOp: "send" | "genesis" | "mint" | "burn" | undefined = undefined;
+    // if (options?.ensureUtxos?.every(val => !val.token) && sendRequests.some(val => (val as TokenSendRequest).tokenId)) {
+    //   tokenOp = "genesis";
+    // } else if (options?.ensureUtxos?.length === 1 && options?.ensureUtxos?.[0].token?.capability === NFTCapability.minting && ) {
+
+    // }
+
     const addTokenChangeOutputs = (
       inputs: UtxoI[],
       outputs: SendRequestType[]
@@ -1189,7 +1204,8 @@ export class Wallet extends BaseWallet {
     const feeEstimate = await getFeeAmount({
       utxos: utxos,
       sendRequests: sendRequests,
-      privateKey: this.privateKey,
+      privateKey: this.privateKey ?? Uint8Array.from([]),
+      sourceAddress: this.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       slpOutputs: [],
       feePaidBy: feePaidBy,
@@ -1201,7 +1217,8 @@ export class Wallet extends BaseWallet {
       bestHeight,
       feePaidBy,
       sendRequests,
-      options?.ensureUtxos || []
+      options?.ensureUtxos || [],
+      options?.tokenOperation
     );
     if (fundingUtxos.length === 0) {
       throw Error(
@@ -1211,20 +1228,24 @@ export class Wallet extends BaseWallet {
     const fee = await getFeeAmount({
       utxos: fundingUtxos,
       sendRequests: sendRequests,
-      privateKey: this.privateKey,
+      privateKey: this.privateKey ?? Uint8Array.from([]),
+      sourceAddress: this.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       slpOutputs: [],
       feePaidBy: feePaidBy,
     });
-    const encodedTransaction = await buildEncodedTransaction(
-      fundingUtxos,
-      sendRequests,
-      this.privateKey,
-      fee,
-      discardChange,
-      [],
-      feePaidBy,
-      changeAddress
+    const { encodedTransaction, sourceOutputs } = await buildEncodedTransaction(
+      {
+        inputs: fundingUtxos,
+        outputs: sendRequests,
+        signingKey: this.privateKey ?? Uint8Array.from([]),
+        sourceAddress: this.cashaddr!,
+        fee,
+        discardChange,
+        slpOutputs: [],
+        feePaidBy,
+        changeAddress,
+      }
     );
 
     const tokenIds = [
@@ -1236,7 +1257,7 @@ export class Wallet extends BaseWallet {
         .map((val) => (val as TokenSendRequest).tokenId),
     ].filter((value, index, array) => array.indexOf(value) === index);
 
-    return { encodedTransaction, tokenIds: tokenIds };
+    return { encodedTransaction, tokenIds, sourceOutputs };
   }
 
   // Submit a raw transaction
@@ -1437,32 +1458,52 @@ export class Wallet extends BaseWallet {
    * @param  {string?} genesisRequest.commitment NFT commitment message
    * @param  {string?} genesisRequest.cashaddr cash address to send the created token UTXO to; if undefined will default to your address
    * @param  {number?} genesisRequest.value satoshi value to send alongside with tokens; if undefined will default to 1000 satoshi
-   * @param  {SendRequestType} sendRequests single or an array of extra send requests (OP_RETURN, value transfer, etc.) to include in genesis transaction
+   * @param  {SendRequestType | SendRequestType[]} sendRequests single or an array of extra send requests (OP_RETURN, value transfer, etc.) to include in genesis transaction
+   * @param  {SendRequestOptionsI} options Options of the send requests
    */
   public async tokenGenesis(
     genesisRequest: TokenGenesisRequest,
-    sendRequests: SendRequestType | SendRequestType[] = []
+    sendRequests: SendRequestType | SendRequestType[] = [],
+    options?: SendRequestOptionsI
   ): Promise<SendResponse> {
     if (!Array.isArray(sendRequests)) {
       sendRequests = [sendRequests];
     }
-    return this.send(
-      [
-        new TokenSendRequest({
-          cashaddr: genesisRequest.cashaddr || this.tokenaddr!,
-          amount: genesisRequest.amount,
-          value: genesisRequest.value,
-          capability: genesisRequest.capability,
-          commitment: genesisRequest.commitment,
-          tokenId: "",
-        }),
-        ...(sendRequests as any),
-      ],
-      {
-        checkTokenQuantities: false,
-        queryBalance: false,
-      }
-    );
+
+    let utxos: UtxoI[];
+    if (options && options.utxoIds) {
+      utxos = options.utxoIds.map((utxoId: UtxoI | string) =>
+        typeof utxoId === "string" ? fromUtxoId(utxoId) : utxoId
+      );
+    } else {
+      utxos = await this.getAddressUtxos(this.cashaddr);
+    }
+
+    const genesisInputs = utxos.filter((val) => val.vout === 0);
+    if (genesisInputs.length === 0) {
+      throw new Error(
+        "No suitable inputs with vout=0 available for new token genesis"
+      );
+    }
+
+    const genesisSendRequest = new TokenSendRequest({
+      cashaddr: genesisRequest.cashaddr || this.tokenaddr!,
+      amount: genesisRequest.amount,
+      value: genesisRequest.value || 1000,
+      capability: genesisRequest.capability,
+      commitment: genesisRequest.commitment,
+      tokenId: utxos[0].txid,
+    });
+    // TODO: remove
+    (genesisSendRequest as any)._isGenesis = true;
+    return this.send([genesisSendRequest, ...(sendRequests as any)], {
+      ...options,
+      utxoIds: utxos,
+      ensureUtxos: [utxos[0]],
+      checkTokenQuantities: false,
+      queryBalance: false,
+      tokenOperation: "genesis",
+    });
   }
 
   /**
@@ -1475,12 +1516,18 @@ export class Wallet extends BaseWallet {
    * @param  {string?} mintRequest.cashaddr cash address to send the created token UTXO to; if undefined will default to your address
    * @param  {number?} mintRequest.value satoshi value to send alongside with tokens; if undefined will default to 1000 satoshi
    * @param  {boolean?} deductTokenAmount if minting token contains fungible amount, deduct from it by amount of minted tokens
+   * @param  {SendRequestOptionsI} options Options of the send requests
    */
   public async tokenMint(
     tokenId: string,
     mintRequests: TokenMintRequest | Array<TokenMintRequest>,
-    deductTokenAmount: boolean = false
+    deductTokenAmount: boolean = false,
+    options?: SendRequestOptionsI
   ): Promise<SendResponse> {
+    if (tokenId?.length !== 64) {
+      throw Error(`Invalid tokenId supplied: ${tokenId}`);
+    }
+
     if (!Array.isArray(mintRequests)) {
       mintRequests = [mintRequests];
     }
@@ -1489,7 +1536,7 @@ export class Wallet extends BaseWallet {
     const nftUtxos = utxos.filter(
       (val) =>
         val.token?.tokenId === tokenId &&
-        val.token?.capability != NFTCapability.none
+        val.token?.capability === NFTCapability.minting
     );
     if (!nftUtxos.length) {
       throw new Error(
@@ -1525,8 +1572,11 @@ export class Wallet extends BaseWallet {
         ),
       ],
       {
+        ...options,
+        ensureUtxos: [nftUtxos[0]],
         checkTokenQuantities: false,
         queryBalance: false,
+        tokenOperation: "mint",
       }
     );
   }
@@ -1545,18 +1595,23 @@ export class Wallet extends BaseWallet {
    * @param  {number?} burnRequest.amount amount of fungible tokens to burn, optional
    * @param  {string?} burnRequest.cashaddr address to return token and satoshi change to
    * @param  {string?} message optional message to include in OP_RETURN
+   * @param  {SendRequestOptionsI} options Options of the send requests
    */
   public async tokenBurn(
     burnRequest: TokenBurnRequest,
-    message?: string
+    message?: string,
+    options?: SendRequestOptionsI
   ): Promise<SendResponse> {
+    if (burnRequest.tokenId?.length !== 64) {
+      throw Error(`Invalid tokenId supplied: ${burnRequest.tokenId}`);
+    }
+
     const utxos = await this.getAddressUtxos(this.cashaddr!);
     const tokenUtxos = utxos.filter(
       (val) =>
         val.token?.tokenId === burnRequest.tokenId &&
         val.token?.capability === burnRequest.capability &&
-        val.token?.commitment === burnRequest.commitment &&
-        val.token?.capability === burnRequest.capability
+        val.token?.commitment === burnRequest.commitment
     );
 
     if (!tokenUtxos.length) {
@@ -1579,6 +1634,16 @@ export class Wallet extends BaseWallet {
         changeSendRequests = [];
         utxoIds.push(tokenUtxos[0]);
       } else {
+        // add utxos to spend from
+        let available = 0;
+        for (const token of tokenUtxos.filter((val) => val.token?.amount)) {
+          utxoIds.push(token);
+          available += token.token?.amount!;
+          if (available >= fungibleBurnAmount) {
+            break;
+          }
+        }
+
         // if there are FT, reduce their amount
         const newAmount = totalFungibleAmount - fungibleBurnAmount;
         const safeNewAmount = Math.max(0, newAmount);
@@ -1599,6 +1664,16 @@ export class Wallet extends BaseWallet {
         changeSendRequests = [];
         utxoIds.push(tokenUtxos[0]);
       } else {
+        // add utxos to spend from
+        let available = 0;
+        for (const token of tokenUtxos.filter((val) => val.token?.amount)) {
+          utxoIds.push(token);
+          available += token.token?.amount!;
+          if (available >= fungibleBurnAmount) {
+            break;
+          }
+        }
+
         // reduce the FT amount
         const newAmount = totalFungibleAmount - fungibleBurnAmount;
         const safeNewAmount = Math.max(0, newAmount);
@@ -1615,9 +1690,11 @@ export class Wallet extends BaseWallet {
 
     const opReturn = OpReturnData.fromString(message || "");
     return this.send([opReturn, ...changeSendRequests], {
+      ...options,
       checkTokenQuantities: false,
       queryBalance: false,
       ensureUtxos: utxoIds.length > 0 ? utxoIds : undefined,
+      tokenOperation: "burn",
     });
   }
 
@@ -1641,7 +1718,9 @@ export class Wallet extends BaseWallet {
    * @returns  {number} fungible token balance
    */
   public async getTokenBalance(tokenId: string): Promise<number> {
-    const utxos = await this.getAddressUtxos(this.cashaddr!);
+    const utxos = (await this.getTokenUtxos(tokenId)).filter(
+      (val) => val.token?.amount
+    );
     return sumTokenAmounts(utxos, tokenId);
   }
 
@@ -1653,7 +1732,9 @@ export class Wallet extends BaseWallet {
    * @returns  {number} non-fungible token balance
    */
   public async getNftTokenBalance(tokenId: string): Promise<number> {
-    const utxos = await this.getTokenUtxos(tokenId);
+    const utxos = (await this.getTokenUtxos(tokenId)).filter(
+      (val) => val.token?.commitment !== undefined
+    );
     return utxos.length;
   }
 
@@ -1661,9 +1742,11 @@ export class Wallet extends BaseWallet {
    * getAllTokenBalances Gets all fungible token balances in this wallet
    * @returns  {Object} a map [tokenId => balance] for all tokens in this wallet
    */
-  public async getAllTokenBalances(): Promise<Object> {
+  public async getAllTokenBalances(): Promise<{ [tokenId: string]: number }> {
     const result = {};
-    const utxos = await this.getTokenUtxos();
+    const utxos = (await this.getTokenUtxos()).filter(
+      (val) => val.token?.amount
+    );
     for (const utxo of utxos) {
       if (!result[utxo.token!.tokenId]) {
         result[utxo.token!.tokenId] = 0;
@@ -1677,9 +1760,13 @@ export class Wallet extends BaseWallet {
    * getAllNftTokenBalances Gets all non-fungible token (NFT) balances in this wallet
    * @returns  {Object} a map [tokenId => balance] for all NFTs in this wallet
    */
-  public async getAllNftTokenBalances(): Promise<Object> {
+  public async getAllNftTokenBalances(): Promise<{
+    [tokenId: string]: number;
+  }> {
     const result = {};
-    const utxos = await this.getTokenUtxos();
+    const utxos = (await this.getTokenUtxos()).filter(
+      (val) => val.token?.commitment !== undefined
+    );
     for (const utxo of utxos) {
       if (!result[utxo.token!.tokenId]) {
         result[utxo.token!.tokenId] = 0;

package/src/wallet/interface.ts

@@ -54,7 +54,9 @@ export interface SendRequestOptionsI {
   awaitTransactionPropagation?: boolean;
   feePaidBy?: FeePaidByEnum;
   checkTokenQuantities?: boolean; // true
+  tokenOperation?: "send" | "genesis" | "mint" | "burn"; // undefined. internal use only
   ensureUtxos?: UtxoI[]; // ensure these inputs will be consumed in the transaction
+  buildUnsigned?: boolean; // false
 }
 
 export interface MnemonicI {

package/src/wallet/model.ts

@@ -4,6 +4,8 @@ import { UnitEnum } from "../enum.js";
 import { NFTCapability, UtxoI } from "../interface.js";
 import { DELIMITER } from "../constant.js";
 import {
+  Input,
+  Output,
   binToNumberUint16LE,
   binToUtf8,
   hexToBin,
@@ -312,11 +314,15 @@ export class OpReturnData {
 
 export type SendRequestArray = Array<string | number | UnitEnum | Buffer>;
 
+export type SourceOutput = Input & Output;
+
 export class SendResponse {
   txId?: string;
   balance?: BalanceResponse;
   explorerUrl?: string;
   tokenIds?: string[];
+  unsignedTransaction?: string; // unsigned transaction hex
+  sourceOutputs?: SourceOutput[]; // source outputs for signing unsigned transactions
 
   constructor({
     txId,