mainnet-js 0.5.9 → 1.0.0-rc.3

package/dist/module/wallet/Wif.js

@@ -1,40 +1,40 @@
 //#region Imports
 // Stable
-import { encodeHdPublicKey, instantiateSecp256k1, instantiateSha256, } from "@bitauth/libauth";
+import { encodeHdPublicKey, secp256k1 } from "@bitauth/libauth";
 // Unstable?
-import { binToHex, CashAddressNetworkPrefix, deriveHdPublicNode, decodePrivateKeyWif, encodePrivateKeyWif, deriveHdPrivateNodeFromSeed, deriveHdPath, generatePrivateKey, instantiateBIP32Crypto, } from "@bitauth/libauth";
+import { binToHex, CashAddressNetworkPrefix, deriveHdPublicNode, decodePrivateKeyWif, encodePrivateKeyWif, deriveHdPrivateNodeFromSeed, deriveHdPath, generatePrivateKey, } from "@bitauth/libauth";
 import { mnemonicToSeedSync, generateMnemonic } from "bip39";
-import { NetworkType, prefixFromNetworkMap, UnitEnum } from "../enum";
-import { Network } from "../interface";
-import { networkPrefixMap } from "../enum";
-import { BaseWallet } from "./Base";
-import { FeePaidByEnum, WalletTypeEnum } from "./enum";
-import { SendRequest, SendResponse, UtxoItem, UtxoResponse, XPubKey, } from "./model";
-import { buildEncodedTransaction, getSuitableUtxos, getFeeAmount, } from "../transaction/Wif";
-import { asSendRequestObject } from "../util/asSendRequestObject";
-import { balanceFromSatoshi, balanceResponseFromSatoshi, } from "../util/balanceObjectFromSatoshi";
-import { checkWifNetwork } from "../util/checkWifNetwork";
-import { deriveCashaddr } from "../util/deriveCashaddr";
-import { derivePrefix, derivePublicKeyHash } from "../util/derivePublicKeyHash";
-import { checkForEmptySeed } from "../util/checkForEmptySeed";
-import { sanitizeUnit } from "../util/sanitizeUnit";
-import { sumUtxoValue } from "../util/sumUtxoValue";
-import { sumSendRequestAmounts } from "../util/sumSendRequestAmounts";
-import { getRelayFeeCache } from "../network/getRelayFeeCache";
-import { RegTestSlp, RegTestWatchSlp, RegTestWifSlp, Slp, TestNetSlp, TestNetWatchSlp, TestNetWifSlp, WatchSlp, WifSlp, } from "./Slp";
+import { NetworkType, prefixFromNetworkMap, UnitEnum } from "../enum.js";
+import { Network, NFTCapability } from "../interface.js";
+import { networkPrefixMap } from "../enum.js";
+import { BaseWallet } from "./Base.js";
+import { FeePaidByEnum, WalletTypeEnum } from "./enum.js";
+import { OpReturnData, SendRequest, SendResponse, TokenSendRequest, UtxoItem, UtxoResponse, XPubKey, } from "./model.js";
+import { buildEncodedTransaction, getSuitableUtxos, getFeeAmount, } from "../transaction/Wif.js";
+import { asSendRequestObject } from "../util/asSendRequestObject.js";
+import { balanceFromSatoshi, balanceResponseFromSatoshi, } from "../util/balanceObjectFromSatoshi.js";
+import { checkWifNetwork } from "../util/checkWifNetwork.js";
+import { deriveCashaddr, deriveTokenaddr } from "../util/deriveCashaddr.js";
+import { derivePrefix, derivePublicKeyHash, } from "../util/derivePublicKeyHash.js";
+import { checkForEmptySeed } from "../util/checkForEmptySeed.js";
+import { sanitizeUnit } from "../util/sanitizeUnit.js";
+import { sumTokenAmounts, sumUtxoValue } from "../util/sumUtxoValue.js";
+import { sumSendRequestAmounts } from "../util/sumSendRequestAmounts.js";
+import { getRelayFeeCache } from "../network/getRelayFeeCache.js";
+import { RegTestSlp, RegTestWatchSlp, RegTestWifSlp, Slp, TestNetSlp, TestNetWatchSlp, TestNetWifSlp, WatchSlp, WifSlp, } from "./Slp.js";
 import axios from "axios";
-import { toCashAddress } from "../util/bchaddr";
-import { RegTestUtil, RegTestWatchUtil, RegTestWifUtil, TestNetUtil, TestNetWatchUtil, TestNetWifUtil, Util, WatchUtil, WifUtil, } from "./Util";
-import { getNetworkProvider } from "../network/index";
-import { generateRandomBytes } from "../util/randomBytes";
-import { SignedMessage } from "../message";
-import { amountInSatoshi } from "../util/amountInSatoshi";
-import { getXPubKey } from "../util/getXPubKey";
-import { DERIVATION_PATHS, DUST_UTXO_THRESHOLD } from "../constant";
-import { getAddressHistory } from "../history/electrumTransformer";
+import { toCashAddress } from "../util/bchaddr.js";
+import { RegTestUtil, RegTestWatchUtil, RegTestWifUtil, TestNetUtil, TestNetWatchUtil, TestNetWifUtil, Util, WatchUtil, WifUtil, } from "./Util.js";
+import { getNetworkProvider } from "../network/index.js";
+import { generateRandomBytes } from "../util/randomBytes.js";
+import { SignedMessage } from "../message/index.js";
+import { amountInSatoshi } from "../util/amountInSatoshi.js";
+import { getXPubKey } from "../util/getXPubKey.js";
+import { DERIVATION_PATHS, DUST_UTXO_THRESHOLD } from "../constant.js";
+import { getAddressHistory } from "../history/electrumTransformer.js";
+import { BCMR } from "./Bcmr.js";
+import { qrAddress } from "../qr/Qr.js";
 //#endregion Imports
-const secp256k1Promise = instantiateSecp256k1();
-const sha256Promise = instantiateSha256();
 /**
  * Class to manage a bitcoin cash wallet.
  */
@@ -95,6 +95,22 @@ export class Wallet extends BaseWallet {
     getNetworkProvider(network = Network.MAINNET) {
         return getNetworkProvider(network);
     }
+    /**
+     * getTokenDepositAddress - get a cashtoken aware wallet deposit address
+     *
+     * @returns The cashtoken aware deposit address as a string
+     */
+    getTokenDepositAddress() {
+        return this.tokenaddr;
+    }
+    /**
+     * getDepositQr - get an address qrcode, encoded for display on the web
+     *
+     * @returns The qrcode for the token aware address
+     */
+    getTokenDepositQr() {
+        return qrAddress(this.getTokenDepositAddress());
+    }
     /**
      *  explorerUrl   Web url to a transaction on a block explorer
      *
@@ -113,6 +129,7 @@ export class Wallet extends BaseWallet {
     getInfo() {
         return {
             cashaddr: this.cashaddr,
+            tokenaddr: this.tokenaddr,
             isTestnet: this.isTestnet,
             name: this.name,
             network: this.network,
@@ -184,6 +201,21 @@ export class Wallet extends BaseWallet {
         const networkType = networkPrefixMap[prefix];
         return new this("", networkType, WalletTypeEnum.Watch).watchOnly(address);
     }
+    /**
+     * fromTokenaddr - create a watch-only wallet in the network derived from the address
+     *
+     * such kind of wallet does not have a private key and is unable to spend any funds
+     * however it still allows to use many utility functions such as getting and watching balance, etc.
+     *
+     * @param address   token aware cashaddress of a wallet
+     *
+     * @returns instantiated wallet
+     */
+    static async fromTokenaddr(address) {
+        const prefix = derivePrefix(address);
+        const networkType = networkPrefixMap[prefix];
+        return new this("", networkType, WalletTypeEnum.Watch).watchOnly(address);
+    }
     /**
      * fromSlpaddr - create an SLP aware watch-only wallet in the network derived from the address
      *
@@ -231,12 +263,11 @@ export class Wallet extends BaseWallet {
         checkForEmptySeed(seed);
         let network = this.isTestnet ? "testnet" : "mainnet";
         this.parentXPubKey = await getXPubKey(seed, this.parentDerivationPath, network);
-        const crypto = await instantiateBIP32Crypto();
-        let hdNode = deriveHdPrivateNodeFromSeed(crypto, seed);
+        let hdNode = deriveHdPrivateNodeFromSeed(seed);
         if (!hdNode.valid) {
             throw Error("Invalid private key derived from mnemonic seed");
         }
-        let zerothChild = deriveHdPath(crypto, hdNode, this.derivationPath);
+        let zerothChild = deriveHdPath(hdNode, this.derivationPath);
         if (typeof zerothChild === "string") {
             throw Error(zerothChild);
         }
@@ -261,12 +292,11 @@ export class Wallet extends BaseWallet {
     // Initialize wallet from a mnemonic phrase
     async fromSeed(mnemonic, derivationPath) {
         this.mnemonic = mnemonic;
-        const crypto = await instantiateBIP32Crypto();
         if (this.mnemonic.length == 0)
             throw Error("refusing to create wallet from empty mnemonic");
         let seed = mnemonicToSeedSync(this.mnemonic);
         checkForEmptySeed(seed);
-        let hdNode = deriveHdPrivateNodeFromSeed(crypto, seed);
+        let hdNode = deriveHdPrivateNodeFromSeed(seed);
         if (!hdNode.valid) {
             throw Error("Invalid private key derived from mnemonic seed");
         }
@@ -278,7 +308,7 @@ export class Wallet extends BaseWallet {
                 this.parentDerivationPath = path.slice(0, -2).join("/");
             }
         }
-        let zerothChild = deriveHdPath(crypto, hdNode, this.derivationPath);
+        let zerothChild = deriveHdPath(hdNode, this.derivationPath);
         if (typeof zerothChild === "string") {
             throw Error(zerothChild);
         }
@@ -291,12 +321,11 @@ export class Wallet extends BaseWallet {
     }
     // Get common xpub paths from zerothChild privateKey
     async deriveHdPaths(hdPaths) {
-        const crypto = await instantiateBIP32Crypto();
         if (!this.mnemonic)
             throw Error("refusing to create wallet from empty mnemonic");
         let seed = mnemonicToSeedSync(this.mnemonic);
         checkForEmptySeed(seed);
-        let hdNode = deriveHdPrivateNodeFromSeed(crypto, seed);
+        let hdNode = deriveHdPrivateNodeFromSeed(seed);
         if (!hdNode.valid) {
             throw Error("Invalid private key derived from mnemonic seed");
         }
@@ -305,15 +334,15 @@ export class Wallet extends BaseWallet {
             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);
+            let childNode = deriveHdPath(hdNode, path);
             if (typeof childNode === "string") {
                 throw Error(childNode);
             }
-            let node = deriveHdPublicNode(crypto, childNode);
+            let node = deriveHdPublicNode(childNode);
             if (typeof node === "string") {
                 throw Error(node);
             }
-            let xPubKey = encodeHdPublicKey(crypto, {
+            let xPubKey = encodeHdPublicKey({
                 network: this.network,
                 node: node,
             });
@@ -348,13 +377,13 @@ export class Wallet extends BaseWallet {
         this.cashaddr = `${addressPrefix}:${addressBase}`;
         this.address = this.cashaddr;
         this.publicKeyHash = derivePublicKeyHash(this.cashaddr);
+        this.tokenaddr = deriveTokenaddr(this.publicKeyHash, this.networkPrefix);
         return this;
     }
     // Initialize wallet from Wallet Import Format
     async fromWIF(secret) {
         checkWifNetwork(secret, this.network);
-        const sha256 = await sha256Promise;
-        let wifResult = decodePrivateKeyWif(sha256, secret);
+        let wifResult = decodePrivateKeyWif(secret);
         if (typeof wifResult === "string") {
             throw Error(wifResult);
         }
@@ -410,8 +439,8 @@ export class Wallet extends BaseWallet {
     //#region Funds
     //
     async getAddressUtxos(address) {
-        if (!this.provider) {
-            throw Error("Attempting to get utxos from wallet without a client");
+        if (!address) {
+            address = this.cashaddr;
         }
         if (this._slpAware) {
             const [bchUtxos, slpOutpoints] = await Promise.all([
@@ -455,18 +484,20 @@ export class Wallet extends BaseWallet {
     }
     // Gets balance by summing value in all utxos in stats
     async getBalanceFromUtxos() {
-        const utxos = await this.getAddressUtxos(this.cashaddr);
-        return await sumUtxoValue(utxos);
+        const utxos = (await this.getAddressUtxos(this.cashaddr)).filter((val) => val.token === undefined);
+        return sumUtxoValue(utxos);
     }
     // Gets balance from fulcrum
     async getBalanceFromProvider() {
-        // TODO not sure why getting the balance from a provider doesn't work
-        if (this._slpAware || this._slpSemiAware) {
-            return await this.getBalanceFromUtxos();
-        }
-        else {
-            return await this.provider.getBalance(this.cashaddr);
-        }
+        // Fulcrum reports balance of all utxos, including tokens, which is undesirable
+        // // TODO not sure why getting the balance from a provider doesn't work
+        // if (this._slpAware || this._slpSemiAware) {
+        //   return await this.getBalanceFromUtxos();
+        // } else {
+        //   return await this.provider!.getBalance(this.cashaddr!);
+        // }
+        // FIXME
+        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
@@ -528,7 +559,34 @@ export class Wallet extends BaseWallet {
             });
         });
     }
-    async getMaxAmountToSend(params = {
+    // sets up a callback to be called upon wallet's token balance change
+    // can be cancelled by calling the function returned from this one
+    watchTokenBalance(tokenId, callback) {
+        let previous = undefined;
+        return this.provider.watchAddressStatus(this.getDepositAddress(), async (_status) => {
+            const balance = await this.getTokenBalance(tokenId);
+            if (previous != balance) {
+                callback(balance);
+            }
+            previous = balance;
+        });
+    }
+    // waits for address token balance to be greater than or equal to the target amount
+    // this call halts the execution
+    async waitForTokenBalance(tokenId, amount) {
+        return new Promise(async (resolve) => {
+            const watchCancel = this.watchTokenBalance(tokenId, async (balance) => {
+                if (balance >= amount) {
+                    await watchCancel();
+                    resolve(balance);
+                }
+            });
+        });
+    }
+    async getTokenInfo(tokenId) {
+        return BCMR.getTokenInfo(tokenId);
+    }
+    async _getMaxAmountToSend(params = {
         outputCount: 1,
         options: {},
     }) {
@@ -557,7 +615,7 @@ export class Wallet extends BaseWallet {
             utxos = params.options.utxoIds.map((utxoId) => UtxoItem.fromId(utxoId).asElectrum());
         }
         else {
-            utxos = await this.getAddressUtxos(this.cashaddr);
+            utxos = (await this.getAddressUtxos(this.cashaddr)).filter((utxo) => !utxo.token);
         }
         // Get current height to assure recently mined coins are not spent.
         const bestHeight = await this.provider.getBlockHeight();
@@ -570,7 +628,7 @@ export class Wallet extends BaseWallet {
         const sendRequests = Array(params.outputCount)
             .fill(0)
             .map(() => sendRequest);
-        const fundingUtxos = await getSuitableUtxos(utxos, undefined, bestHeight, feePaidBy);
+        const fundingUtxos = await getSuitableUtxos(utxos, undefined, bestHeight, feePaidBy, sendRequests);
         const relayFeePerByteInSatoshi = await getRelayFeeCache(this.provider);
         const fee = await getFeeAmount({
             utxos: fundingUtxos,
@@ -580,11 +638,18 @@ export class Wallet extends BaseWallet {
             slpOutputs: [],
             feePaidBy: feePaidBy,
         });
-        const spendableAmount = await sumUtxoValue(fundingUtxos);
+        const spendableAmount = sumUtxoValue(fundingUtxos);
         let result = spendableAmount - fee;
         if (result < 0) {
             result = 0;
         }
+        return { value: result, utxos: fundingUtxos };
+    }
+    async getMaxAmountToSend(params = {
+        outputCount: 1,
+        options: {},
+    }) {
+        const { value: result } = await this._getMaxAmountToSend(params);
         return await balanceResponseFromSatoshi(result);
     }
     /**
@@ -596,7 +661,7 @@ export class Wallet extends BaseWallet {
      *
      */
     async send(requests, options) {
-        let encodedTransaction = await this.encodeTransaction(requests, undefined, options);
+        let { encodedTransaction, tokenIds } = await this.encodeTransaction(requests, undefined, options);
         const awaitTransactionPropagation = !options ||
             options.awaitTransactionPropagation === undefined ||
             options.awaitTransactionPropagation;
@@ -608,6 +673,7 @@ export class Wallet extends BaseWallet {
             resp.balance = (await this.getBalance());
         }
         resp.explorerUrl = this.explorerUrl(resp.txId);
+        resp.tokenIds = tokenIds;
         return resp;
     }
     /**
@@ -638,19 +704,20 @@ export class Wallet extends BaseWallet {
      * @returns the transaction id sent to the network
      */
     async sendMaxRaw(cashaddr, options) {
-        let maxSpendableAmount = await this.getMaxAmountToSend({
+        let { value: maxSpendableAmount, utxos } = await this._getMaxAmountToSend({
             outputCount: 1,
             options: options,
         });
-        if (maxSpendableAmount.sat === undefined) {
-            throw Error("no Max amount to send");
+        if (!options) {
+            options = {};
         }
+        options.utxoIds = utxos;
         let sendRequest = new SendRequest({
             cashaddr: cashaddr,
-            value: maxSpendableAmount.sat,
+            value: maxSpendableAmount,
             unit: "sat",
         });
-        const encodedTransaction = await this.encodeTransaction([sendRequest], true, options);
+        const { encodedTransaction } = await this.encodeTransaction([sendRequest], true, options);
         const awaitTransactionPropagation = !options ||
             options.awaitTransactionPropagation === undefined ||
             options.awaitTransactionPropagation;
@@ -691,14 +758,53 @@ export class Wallet extends BaseWallet {
         else {
             changeAddress = "";
         }
+        let checkTokenQuantities = true;
+        if (options && options.checkTokenQuantities === false) {
+            checkTokenQuantities = false;
+        }
         // get inputs from options or query all inputs
         let utxos;
         if (options && options.utxoIds) {
-            utxos = options.utxoIds.map((utxoId) => UtxoItem.fromId(utxoId).asElectrum());
+            utxos = options.utxoIds.map((utxoId) => typeof utxoId === "string"
+                ? UtxoItem.fromId(utxoId).asElectrum()
+                : utxoId);
         }
         else {
             utxos = await this.getAddressUtxos(this.cashaddr);
         }
+        const addTokenChangeOutputs = (inputs, outputs) => {
+            // allow for implicit token burn if the total amount sent is less than user had
+            // allow for token genesis, creating more tokens than we had before (0)
+            if (!checkTokenQuantities) {
+                return;
+            }
+            const allTokenInputs = inputs.filter((val) => val.token);
+            const allTokenOutputs = outputs.filter((val) => val instanceof TokenSendRequest);
+            const tokenIds = allTokenOutputs
+                .map((val) => val.tokenId)
+                .filter((val, idx, arr) => arr.indexOf(val) === idx);
+            for (let tokenId of tokenIds) {
+                const tokenInputs = allTokenInputs.filter((val) => val.token?.tokenId === tokenId);
+                const inputAmountSum = tokenInputs.reduce((prev, cur) => prev + cur.token.amount, 0);
+                const tokenOutputs = allTokenOutputs.filter((val) => val.tokenId === tokenId);
+                const outputAmountSum = tokenOutputs.reduce((prev, cur) => prev + cur.amount, 0);
+                const change = inputAmountSum - outputAmountSum;
+                if (change < 0) {
+                    throw new Error("Not enough token amount to send");
+                }
+                if (change > 0) {
+                    outputs.push(new TokenSendRequest({
+                        cashaddr: changeAddress || this.cashaddr,
+                        amount: change,
+                        tokenId: tokenId,
+                        commitment: tokenOutputs[0].commitment,
+                        capability: tokenOutputs[0].capability,
+                        value: tokenOutputs[0].value,
+                    }));
+                }
+            }
+        };
+        addTokenChangeOutputs(utxos, sendRequests);
         const bestHeight = await this.provider.getBlockHeight();
         const spendAmount = await sumSendRequestAmounts(sendRequests);
         if (utxos.length === 0) {
@@ -716,7 +822,7 @@ export class Wallet extends BaseWallet {
             slpOutputs: [],
             feePaidBy: feePaidBy,
         });
-        const fundingUtxos = await getSuitableUtxos(utxos, BigInt(spendAmount) + BigInt(feeEstimate), bestHeight, feePaidBy);
+        const fundingUtxos = await getSuitableUtxos(utxos, BigInt(spendAmount) + BigInt(feeEstimate), bestHeight, feePaidBy, sendRequests);
         if (fundingUtxos.length === 0) {
             throw Error("The available inputs couldn't satisfy the request with fees");
         }
@@ -729,7 +835,15 @@ export class Wallet extends BaseWallet {
             feePaidBy: feePaidBy,
         });
         const encodedTransaction = await buildEncodedTransaction(fundingUtxos, sendRequests, this.privateKey, fee, discardChange, [], feePaidBy, changeAddress);
-        return encodedTransaction;
+        const tokenIds = [
+            ...fundingUtxos
+                .filter((val) => val.token?.tokenId)
+                .map((val) => val.token.tokenId),
+            ...sendRequests
+                .filter((val) => val instanceof TokenSendRequest)
+                .map((val) => val.tokenId),
+        ].filter((value, index, array) => array.indexOf(value) === index);
+        return { encodedTransaction, tokenIds: tokenIds };
     }
     // Submit a raw transaction
     async submitTransaction(transaction, awaitPropagation = true) {
@@ -830,14 +944,21 @@ export class Wallet extends BaseWallet {
     //#endregion Funds
     //#region Private implementation details
     async deriveInfo() {
-        const sha256 = await sha256Promise;
-        const secp256k1 = await secp256k1Promise;
-        this.publicKey = secp256k1.derivePublicKeyUncompressed(this.privateKey);
-        this.publicKeyCompressed = secp256k1.derivePublicKeyCompressed(this.privateKey);
+        const publicKey = secp256k1.derivePublicKeyUncompressed(this.privateKey);
+        if (typeof publicKey === "string") {
+            throw new Error(publicKey);
+        }
+        this.publicKey = publicKey;
+        const publicKeyCompressed = secp256k1.derivePublicKeyCompressed(this.privateKey);
+        if (typeof publicKeyCompressed === "string") {
+            throw new Error(publicKeyCompressed);
+        }
+        this.publicKeyCompressed = publicKeyCompressed;
         const networkType = this.network === NetworkType.Regtest ? NetworkType.Testnet : this.network;
-        this.privateKeyWif = encodePrivateKeyWif(sha256, this.privateKey, networkType);
+        this.privateKeyWif = encodePrivateKeyWif(this.privateKey, networkType);
         checkWifNetwork(this.privateKeyWif, this.network);
-        this.cashaddr = (await deriveCashaddr(this.privateKey, this.networkPrefix));
+        this.cashaddr = deriveCashaddr(this.privateKey, this.networkPrefix);
+        this.tokenaddr = deriveTokenaddr(this.privateKey, this.networkPrefix);
         this.address = this.cashaddr;
         this.publicKeyHash = derivePublicKeyHash(this.cashaddr);
         return this;
@@ -852,6 +973,217 @@ export class Wallet extends BaseWallet {
     async verify(message, sig, publicKey) {
         return await Wallet.signedMessage.verify(message, sig, this.cashaddr, publicKey);
     }
+    //#endregion Signing
+    //#region Cashtokens
+    /**
+     * Create new cashtoken, both funglible and/or non-fungible (NFT)
+     * Refer to spec https://github.com/bitjson/cashtokens
+     * @param  {number} genesisRequest.amount amount of *fungible* tokens to create
+     * @param  {NFTCapability?} genesisRequest.capability capability of new NFT
+     * @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
+     */
+    async tokenGenesis(genesisRequest) {
+        return this.send(new TokenSendRequest({
+            cashaddr: genesisRequest.cashaddr || this.cashaddr,
+            amount: genesisRequest.amount,
+            value: genesisRequest.value,
+            capability: genesisRequest.capability,
+            commitment: genesisRequest.commitment,
+            tokenId: "",
+        }), {
+            checkTokenQuantities: false,
+            queryBalance: false,
+        });
+    }
+    /**
+     * Mint new NFT cashtokens using an existing minting token
+     * Refer to spec https://github.com/bitjson/cashtokens
+     * @param  {string} tokenId tokenId of an NFT to mint
+     * @param  {TokenMintRequest | TokenMintRequest[]} mintRequests mint requests with new token properties and recipients
+     * @param  {NFTCapability?} mintRequest.capability capability of new NFT
+     * @param  {string?} mintRequest.commitment NFT commitment message
+     * @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
+     */
+    async tokenMint(tokenId, mintRequests, deductTokenAmount = false) {
+        if (!Array.isArray(mintRequests)) {
+            mintRequests = [mintRequests];
+        }
+        const utxos = await this.getAddressUtxos(this.cashaddr);
+        const nftUtxos = utxos.filter((val) => val.token?.tokenId === tokenId &&
+            val.token?.capability != NFTCapability.none);
+        if (!nftUtxos.length) {
+            throw new Error("You do not have any token UTXOs with minting capability for specified tokenId");
+        }
+        const newAmount = deductTokenAmount && nftUtxos[0].token.amount > 0
+            ? nftUtxos[0].token.amount - mintRequests.length
+            : nftUtxos[0].token.amount;
+        const safeNewAmount = Math.max(0, newAmount);
+        const mintingInput = new TokenSendRequest({
+            cashaddr: this.cashaddr,
+            tokenId: tokenId,
+            capability: nftUtxos[0].token.capability,
+            commitment: nftUtxos[0].token.commitment,
+            amount: safeNewAmount,
+            value: nftUtxos[0].satoshis,
+        });
+        return this.send([
+            mintingInput,
+            ...mintRequests.map((val) => new TokenSendRequest({
+                cashaddr: val.cashaddr || this.cashaddr,
+                amount: 0,
+                tokenId: tokenId,
+                value: val.value,
+                capability: val.capability,
+                commitment: val.commitment,
+            })),
+        ], {
+            checkTokenQuantities: false,
+            queryBalance: false,
+        });
+    }
+    /**
+     * Perform an explicit token burning by spending a token utxo to an OP_RETURN
+     *
+     * Behaves differently for fungible and non-fungible tokens:
+     *  * NFTs are always "destroyed"
+     *  * FTs' amount is reduced by the amount specified, if 0 FT amount is left and no NFT present, the token is "destroyed"
+     *
+     * Refer to spec https://github.com/bitjson/cashtokens
+     * @param  {string} burnRequest.tokenId tokenId of a token to burn
+     * @param  {NFTCapability} burnRequest.capability capability of the NFT token to select, optional
+     * @param  {string?} burnRequest.commitment commitment of the NFT token to select, optional
+     * @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
+     */
+    async tokenBurn(burnRequest, message) {
+        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);
+        if (!tokenUtxos.length) {
+            throw new Error("You do not have suitable token UTXOs to perform burn");
+        }
+        const totalFungibleAmount = tokenUtxos.reduce((prev, cur) => prev + (cur.token?.amount || 0), 0);
+        const fungibleBurnAmount = burnRequest.amount && burnRequest.amount > 0 ? burnRequest.amount : 0;
+        const hasNFT = burnRequest.capability || burnRequest.commitment;
+        let utxoIds = [];
+        let changeSendRequests;
+        if (hasNFT) {
+            // does not have FT tokens, let us destroy the token completely
+            if (totalFungibleAmount === 0) {
+                changeSendRequests = [];
+                utxoIds.push(tokenUtxos[0]);
+            }
+            else {
+                // if there are FT, reduce their amount
+                const newAmount = totalFungibleAmount - fungibleBurnAmount;
+                const safeNewAmount = Math.max(0, newAmount);
+                changeSendRequests = [
+                    new TokenSendRequest({
+                        cashaddr: burnRequest.cashaddr || this.cashaddr,
+                        tokenId: burnRequest.tokenId,
+                        capability: burnRequest.capability,
+                        commitment: burnRequest.commitment,
+                        amount: safeNewAmount,
+                        value: tokenUtxos[0].satoshis,
+                    }),
+                ];
+            }
+        }
+        else {
+            // if we are burning last fughible tokens, let us destroy the token completely
+            if (totalFungibleAmount === fungibleBurnAmount) {
+                changeSendRequests = [];
+                utxoIds.push(tokenUtxos[0]);
+            }
+            else {
+                // reduce the FT amount
+                const newAmount = totalFungibleAmount - fungibleBurnAmount;
+                const safeNewAmount = Math.max(0, newAmount);
+                changeSendRequests = [
+                    new TokenSendRequest({
+                        cashaddr: burnRequest.cashaddr || this.cashaddr,
+                        tokenId: burnRequest.tokenId,
+                        amount: safeNewAmount,
+                        value: tokenUtxos[0].satoshis,
+                    }),
+                ];
+            }
+        }
+        const opReturn = OpReturnData.fromString(message || "");
+        return this.send([opReturn, ...changeSendRequests], {
+            checkTokenQuantities: false,
+            queryBalance: false,
+            utxoIds: utxoIds.length > 0 ? utxoIds : undefined,
+        });
+    }
+    /**
+     * getTokenUtxos Get unspent token outputs for the wallet
+     * will return utxos only for the specified token if `tokenId` provided
+     * @param  {string?} tokenId tokenId (category) to filter utxos by, if not set will return utxos from all tokens
+     * @returns  {UtxoI[]} token utxos
+     */
+    async getTokenUtxos(tokenId) {
+        const utxos = await this.getAddressUtxos(this.address);
+        return utxos.filter((val) => tokenId ? val.token?.tokenId === tokenId : val.token);
+    }
+    /**
+     * getTokenBalance Gets fungible token balance
+     * for NFT token balance see @ref getNftTokenBalance
+     * @param  {string} tokenId tokenId to get balance for
+     * @returns  {number} fungible token balance
+     */
+    async getTokenBalance(tokenId) {
+        const utxos = await this.getAddressUtxos(this.cashaddr);
+        return sumTokenAmounts(utxos, tokenId);
+    }
+    /**
+     * getNftTokenBalance Gets non-fungible token (NFT) balance for a particula tokenId
+     * disregards fungible token balances
+     * for fungible token balance see @ref getTokenBalance
+     * @param  {string} tokenId tokenId to get balance for
+     * @returns  {number} non-fungible token balance
+     */
+    async getNftTokenBalance(tokenId) {
+        const utxos = await this.getTokenUtxos(tokenId);
+        return utxos.length;
+    }
+    /**
+     * getAllTokenBalances Gets all fungible token balances in this wallet
+     * @returns  {Object} a map [tokenId => balance] for all tokens in this wallet
+     */
+    async getAllTokenBalances() {
+        const result = {};
+        const utxos = await this.getTokenUtxos();
+        for (const utxo of utxos) {
+            if (!result[utxo.token.tokenId]) {
+                result[utxo.token.tokenId] = 0;
+            }
+            result[utxo.token.tokenId] += utxo.token.amount;
+        }
+        return result;
+    }
+    /**
+     * getAllNftTokenBalances Gets all non-fungible token (NFT) balances in this wallet
+     * @returns  {Object} a map [tokenId => balance] for all NFTs in this wallet
+     */
+    async getAllNftTokenBalances() {
+        const result = {};
+        const utxos = await this.getTokenUtxos();
+        for (const utxo of utxos) {
+            if (!result[utxo.token.tokenId]) {
+                result[utxo.token.tokenId] = 0;
+            }
+            result[utxo.token.tokenId] += 1;
+        }
+        return result;
+    }
 }
 Wallet.signedMessage = new SignedMessage();
 /**