mainnet-js 1.0.7 → 1.0.8

package/src/network/interface.ts

@@ -19,23 +19,21 @@ export interface ElectrumClusterParams {
   timeout: number;
 }
 
+export interface ElectrumTokenData {
+  amount: string;
+  category: string;
+  nft?: {
+    capability?: NFTCapability;
+    commitment?: string;
+  };
+}
+
 export interface ElectrumUtxo {
   tx_pos: number;
   value: number;
   tx_hash: string;
   height: number;
-  token_data:
-    | {
-        amount: string;
-        category: string;
-        nft:
-          | {
-              capability: NFTCapability | undefined;
-              commitment: string | undefined;
-            }
-          | undefined;
-      }
-    | undefined;
+  token_data?: ElectrumTokenData;
 }
 
 export interface ElectrumRawTransaction {
@@ -65,12 +63,14 @@ export interface ElectrumRawTransactionVin {
   vout: number;
   value?: number; // optional extention by mainnet.cash
   address?: string; // optional extension by mainnet.cash
+  tokenData?: ElectrumTokenData; // optional extension by mainnet.cash
 }
 
 export interface ElectrumRawTransactionVout {
   n: number;
   scriptPubKey: ElectrumRawTransactionVoutScriptPubKey;
   value: number;
+  tokenData?: ElectrumTokenData;
 }
 
 export interface ElectrumRawTransactionVoutScriptPubKey {

package/src/transaction/Wif.ts

@@ -286,7 +286,8 @@ export async function getSuitableUtxos(
   amountRequired: BigInt | undefined,
   bestHeight: number,
   feePaidBy: FeePaidByEnum,
-  requests: SendRequestType[]
+  requests: SendRequestType[],
+  ensureUtxos: UtxoI[] = []
 ): Promise<UtxoI[]> {
   let suitableUtxos: UtxoI[] = [];
   let amountAvailable = BigInt(0);
@@ -294,6 +295,16 @@ export async function getSuitableUtxos(
   const tokenRequests = requests.filter(
     (val) => val instanceof TokenSendRequest
   ) as TokenSendRequest[];
+
+  // if we do a new token genesis, we shall filter all token utxos out
+  const isTokenGenesis = tokenRequests.some(
+    (val) => !val.tokenId || (val as any)._isGenesis
+  );
+  const bchOnlyTransfer = tokenRequests.length === 0;
+  let filteredInputs =
+    isTokenGenesis || bchOnlyTransfer
+      ? inputs.slice(0).filter((val) => !val.token)
+      : inputs.slice();
   const tokenIds = tokenRequests
     .map((val) => val.tokenId)
     .filter((value, index, array) => array.indexOf(value) === index);
@@ -304,8 +315,6 @@ export async function getSuitableUtxos(
     tokenAmountsRequired.push({ tokenId, requiredAmount });
   }
 
-  let filteredInputs = inputs.slice(0);
-
   // find suitable token inputs first
   for (const { tokenId, requiredAmount } of tokenAmountsRequired) {
     let tokenAmountAvailable = 0;
@@ -325,10 +334,10 @@ export async function getSuitableUtxos(
     }
   }
 
-  // find plain outputs
+  // find plain bch outputs
   for (const u of filteredInputs) {
     if (u.token) {
-      // continue;
+      continue;
     }
 
     if (u.coinbase && u.height && bestHeight) {
@@ -347,14 +356,20 @@ export async function getSuitableUtxos(
     }
   }
 
+  const addEnsured = (suitableUtxos) => {
+    return [...suitableUtxos, ...ensureUtxos].filter(
+      (val, index, array) => array.indexOf(val) === index
+    );
+  };
+
   // if the fee is split with a feePaidBy option, skip checking change.
   if (feePaidBy && feePaidBy != FeePaidByEnum.change) {
-    return suitableUtxos;
+    return addEnsured(suitableUtxos);
   }
 
   // If the amount needed is met, or no amount is given, return
   if (typeof amountRequired === "undefined") {
-    return suitableUtxos;
+    return addEnsured(suitableUtxos);
   } else if (amountAvailable < amountRequired) {
     let e = Error(
       `Amount required was not met, ${amountRequired} satoshis needed, ${amountAvailable} satoshis available`
@@ -365,7 +380,7 @@ export async function getSuitableUtxos(
     };
     throw e;
   } else {
-    return suitableUtxos;
+    return addEnsured(suitableUtxos);
   }
 }
 

package/src/util/deriveCashaddr.ts

@@ -131,3 +131,9 @@ export function isTokenaddr(address: string): boolean {
     ].indexOf(result.version) !== -1
   );
 }
+
+export function checkTokenaddr(cashaddr: string, enforce: boolean) {
+  if (enforce && !isTokenaddr(cashaddr)) {
+    throw new Error("Error trying to send to a non-tokenaware cash address");
+  }
+}

package/src/wallet/Cashtokens.test.ts

@@ -1,9 +1,15 @@
 import { RegTestWallet, TestNetWallet, Wallet } from "./Wif";
 import { initProviders, disconnectProviders } from "../network/Connection";
-import { SendRequest, TokenMintRequest, TokenSendRequest } from "./model";
+import {
+  SendRequest,
+  SendResponse,
+  TokenMintRequest,
+  TokenSendRequest,
+} from "./model";
 import { Network, NFTCapability } from "../interface";
 import { binToHex, utf8ToBin } from "@bitauth/libauth";
 import { delay } from "../util";
+import { Config } from "../config";
 
 beforeAll(async () => {
   await initProviders();
@@ -194,9 +200,11 @@ describe(`Test cashtokens`, () => {
     const response = await alice.tokenMint(tokenId, [
       new TokenMintRequest({
         cashaddr: alice.cashaddr!,
+        commitment: "test",
       }),
       new TokenMintRequest({
         cashaddr: alice.cashaddr!,
+        commitment: "test2",
       }),
     ]);
     expect(await alice.getTokenBalance(tokenId)).toBe(0);
@@ -313,7 +321,7 @@ describe(`Test cashtokens`, () => {
     expect(tokenId).toEqual(response.tokenIds![0]);
   });
 
-  test("Test explicit burning of FT+NFT", async () => {
+  test("Test explicit burning of FT and NFT", async () => {
     const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
     const genesisResponse = await alice.tokenGenesis({
       cashaddr: alice.cashaddr!,
@@ -439,13 +447,15 @@ describe(`Test cashtokens`, () => {
     expect(bobUtxos[1].satoshis).toBe(3349);
   });
 
-  test("Test cashtoken waiting and watching balance", async () => {
+  test("Test cashtoken waiting and watching", async () => {
     const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
     const bob = await RegTestWallet.newRandom();
 
     const genesisResponse = await alice.tokenGenesis({
       amount: 100,
       value: 5000,
+      capability: NFTCapability.minting,
+      commitment: "test",
       cashaddr: alice.cashaddr!,
     });
 
@@ -457,16 +467,17 @@ describe(`Test cashtokens`, () => {
     expect(tokenUtxos[0].satoshis).toBe(5000);
 
     let seenBalance = 0;
+    let sendResponse: SendResponse = {};
     setTimeout(
-      () =>
-        alice.send([
+      async () =>
+        (sendResponse = await alice.send([
           new TokenSendRequest({
             cashaddr: bob.cashaddr!,
             amount: 100,
             tokenId: tokenId,
             value: 1500,
           }),
-        ]),
+        ])),
       0
     );
 
@@ -474,10 +485,141 @@ describe(`Test cashtokens`, () => {
       seenBalance = balance;
     });
 
+    let bobTxId = ".";
+    const txCancel = bob.watchAddressTokenTransactions((tx) => {
+      bobTxId = tx.txid;
+    });
+
     const balance = await bob.waitForTokenBalance(tokenId, 100);
+    await delay(500);
     expect(balance).toBe(100);
     expect(seenBalance).toBe(100);
+    expect(sendResponse.txId).toBe(bobTxId);
     await cancel();
+    await txCancel();
     await delay(500);
   });
+
+  test("Test double genesis should not burn tokens", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      amount: 100,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await bob.getTokenBalance(tokenId);
+
+    expect(tokenBalance).toBe(100);
+    const tokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+
+    const genesis2Response = await bob.tokenGenesis({
+      amount: 200,
+    });
+
+    const tokenId2 = genesis2Response.tokenIds![0];
+    const tokenBalance2 = await bob.getTokenBalance(tokenId2);
+    expect(tokenBalance2).toBe(200);
+    const tokenUtxos2 = await bob.getTokenUtxos(tokenId2);
+    expect(tokenUtxos2.length).toBe(1);
+
+    expect((await bob.getTokenUtxos()).length).toBe(2);
+  });
+
+  test("Test sending tokens should not burn tokens", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      amount: 100,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await bob.getTokenBalance(tokenId);
+
+    expect(tokenBalance).toBe(100);
+    const tokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+
+    const genesis2Response = await bob.tokenGenesis({
+      amount: 200,
+    });
+
+    const tokenId2 = genesis2Response.tokenIds![0];
+    const tokenBalance2 = await bob.getTokenBalance(tokenId2);
+    expect(tokenBalance2).toBe(200);
+    const tokenUtxos2 = await bob.getTokenUtxos(tokenId2);
+    expect(tokenUtxos2.length).toBe(1);
+
+    expect((await bob.getTokenUtxos()).length).toBe(2);
+
+    const charlie = await RegTestWallet.newRandom();
+    await bob.send({
+      cashaddr: charlie.cashaddr!,
+      tokenId: tokenId,
+      amount: 50,
+    });
+    expect((await bob.getTokenUtxos()).length).toBe(2);
+    expect((await charlie.getTokenUtxos()).length).toBe(1);
+    expect(await bob.getTokenBalance(tokenId)).toBe(50);
+    expect(await charlie.getTokenBalance(tokenId)).toBe(50);
+  });
+
+  test("Test sending bch should not burn tokens", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      amount: 100,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await bob.getTokenBalance(tokenId);
+
+    expect(tokenBalance).toBe(100);
+    const tokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+
+    await bob.send({ cashaddr: alice.cashaddr!, value: 1000, unit: "sat" });
+
+    const tokenBalance2 = await bob.getTokenBalance(tokenId);
+    expect(tokenBalance2).toBe(100);
+    const tokenUtxos2 = await bob.getTokenUtxos(tokenId);
+    expect(tokenUtxos2.length).toBe(1);
+  });
+
+  test("Test enforcing tokenaddresses", async () => {
+    const bob = await RegTestWallet.newRandom();
+
+    const previousValue = Config.ValidateTokenAddresses;
+
+    const wrap = (addr) => {
+      return new Promise(() => {
+        return new TokenSendRequest({ cashaddr: addr, tokenId: "" });
+      });
+    };
+
+    Config.ValidateTokenAddresses = false;
+    expect(wrap(bob.cashaddr)).resolves.not.toThrow();
+    expect(wrap(bob.tokenaddr)).resolves.not.toThrow();
+
+    Config.ValidateTokenAddresses = true;
+    expect(wrap(bob.cashaddr)).rejects.toThrow();
+    expect(wrap(bob.tokenaddr)).resolves.not.toThrow();
+
+    Config.ValidateTokenAddresses = previousValue;
+  });
 });

package/src/wallet/Util.ts

@@ -100,6 +100,7 @@ export class Util {
           .vout.find((val) => val.n === input.vout)!;
         input.address = output.scriptPubKey.addresses[0];
         input.value = output.value;
+        input.tokenData = output.tokenData;
       });
     }
 

package/src/wallet/Wif.test.ts

@@ -806,11 +806,11 @@ describe(`Wallet subscriptions`, () => {
     });
 
     let bobWatchResult = false;
-    const bobWatchCancel = (
-      bob.provider! as ElectrumNetworkProvider
-    ).watchAddressStatus(bob.getDepositAddress(), (_status) => {
+    let bobTransactionId = "";
+    const bobWatchCancel = bob.watchAddress((txHash) => {
       bobWatchCancel();
       bobWatchResult = true;
+      bobTransactionId = txHash;
     });
 
     let bobBalanceWatchResult = false;
@@ -847,7 +847,7 @@ describe(`Wallet subscriptions`, () => {
       blockNumberWaitResult = true;
     }, 0);
 
-    await alice.send({
+    const sendResponse = await alice.send({
       cashaddr: bob.getDepositAddress(),
       value: 0.001,
       unit: "bch",
@@ -862,6 +862,7 @@ describe(`Wallet subscriptions`, () => {
     expect(waitBalanceResult).toBe(true);
     expect(aliceWatchResult).toBe(true);
     expect(bobWatchResult).toBe(true);
+    expect(bobTransactionId).toBe(sendResponse.txId);
     expect(bobBalanceWatchResult).toBe(true);
     expect(blockWatchResult).toBe(true);
     expect(blockWaitResult).toBe(true);

package/src/wallet/Wif.ts

@@ -711,25 +711,32 @@ export class Wallet extends BaseWallet {
     return this.getBalanceFromUtxos();
   }
 
-  // // waiting for any transaction hash of this wallet
-  // // commented out until fulcrum supports new method https://github.com/cculianu/Fulcrum/pull/89
-  // public watchAddress(callback: (txHash: string) => void): CancelWatchFn {
-  //   return (this.provider! as ElectrumNetworkProvider).watchAddress(
-  //     this.getDepositAddress(),
-  //     callback
-  //   );
-  // }
-
-  // // waiting for any transaction of this wallet
-  // // commented out until fulcrum supports new method https://github.com/cculianu/Fulcrum/pull/89
-  // public watchAddressTransactions(
-  //   callback: (tx: ElectrumRawTransaction) => void
-  // ): CancelWatchFn {
-  //   return (this.provider! as ElectrumNetworkProvider).watchAddressTransactions(
-  //     this.getDepositAddress(),
-  //     callback
-  //   );
-  // }
+  // watching for any transaction hash of this wallet
+  public watchAddress(callback: (txHash: string) => void): CancelWatchFn {
+    return (this.provider! as ElectrumNetworkProvider).watchAddress(
+      this.getDepositAddress(),
+      callback
+    );
+  }
+
+  // watching for any transaction of this wallet
+  public watchAddressTransactions(
+    callback: (tx: ElectrumRawTransaction) => void
+  ): CancelWatchFn {
+    return (this.provider! as ElectrumNetworkProvider).watchAddressTransactions(
+      this.getDepositAddress(),
+      callback
+    );
+  }
+
+  // watching for cashtoken transaction of this wallet
+  public watchAddressTokenTransactions(
+    callback: (tx: ElectrumRawTransaction) => void
+  ): CancelWatchFn {
+    return (
+      this.provider! as ElectrumNetworkProvider
+    ).watchAddressTokenTransactions(this.getDepositAddress(), callback);
+  }
 
   // sets up a callback to be called upon wallet's balance change
   // can be cancelled by calling the function returned from this one
@@ -1195,7 +1202,8 @@ export class Wallet extends BaseWallet {
       BigInt(spendAmount) + BigInt(feeEstimate),
       bestHeight,
       feePaidBy,
-      sendRequests
+      sendRequests,
+      options?.ensureUtxos || []
     );
     if (fundingUtxos.length === 0) {
       throw Error(
@@ -1603,7 +1611,7 @@ export class Wallet extends BaseWallet {
     return this.send([opReturn, ...changeSendRequests], {
       checkTokenQuantities: false,
       queryBalance: false,
-      utxoIds: utxoIds.length > 0 ? utxoIds : undefined,
+      ensureUtxos: utxoIds.length > 0 ? utxoIds : undefined,
     });
   }
 

package/src/wallet/interface.ts

@@ -54,6 +54,7 @@ export interface SendRequestOptionsI {
   awaitTransactionPropagation?: boolean;
   feePaidBy?: FeePaidByEnum;
   checkTokenQuantities?: boolean; // true
+  ensureUtxos?: UtxoI[]; // ensure these inputs will be consumed in the transaction
 }
 
 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 { utf8ToBin } from "@bitauth/libauth";
+import { Config } from "../config.js";
+import { checkTokenaddr } from "../util/deriveCashaddr.js";
 
 // These are the minimal models used to provide types for the express server
 //
@@ -116,6 +118,8 @@ export class TokenSendRequest {
     capability?: NFTCapability;
     commitment?: string;
   }) {
+    checkTokenaddr(cashaddr, Config.ValidateTokenAddresses);
+
     this.cashaddr = cashaddr;
     this.value = value;
     this.amount = amount || 0;
@@ -142,8 +146,7 @@ export class TokenMintRequest {
     cashaddr?: string;
     value?: number;
   }) {
-    // be explicit about minting capability for new NFTs
-    this.capability = capability || NFTCapability.none;
+    this.capability = capability;
     this.commitment = commitment;
     this.cashaddr = cashaddr;
     this.value = value;