mainnet-js 2.6.7 → 2.7.1

package/dist/module/wallet/Base.js

@@ -1,17 +1,64 @@
-import { NetworkType } from "../enum.js";
-import { getRuntimePlatform } from "../util/getRuntimePlatform.js";
-import { qrAddress } from "../qr/Qr.js";
-import { WalletTypeEnum } from "./enum.js";
+import { binToHex, CashAddressNetworkPrefix, CashAddressType, decodeCashAddress, encodeCashAddress, } from "@bitauth/libauth";
+import { DUST_UTXO_THRESHOLD } from "../constant.js";
+import { networkPrefixMap, NetworkType, prefixFromNetworkMap, UnitEnum, } from "../enum.js";
+import { getAddressHistory } from "../history/electrumTransformer.js";
+import { NFTCapability } from "../interface.js";
+import { SignedMessage } from "../message/signed.js";
+import { getNetworkProvider } from "../network/default.js";
+import { getRelayFeeCache } from "../network/getRelayFeeCache.js";
+import { buildEncodedTransaction, getFeeAmount, getFeeAmountSimple, getSuitableUtxos, } from "../transaction/Wif.js";
+import { balanceFromSatoshi, balanceResponseFromSatoshi, } from "../util/balanceObjectFromSatoshi.js";
+import { checkUtxos } from "../util/checkUtxos.js";
+import { derivePrefix } from "../util/derivePublicKeyHash.js";
+import { amountInSatoshi, asSendRequestObject, deriveTokenaddr, getRuntimePlatform, hexToBin, sumTokenAmounts, sumUtxoValue, toTokenaddr, } from "../util/index.js";
+import { sanitizeUnit } from "../util/sanitizeUnit.js";
+import { sumSendRequestAmounts } from "../util/sumSendRequestAmounts.js";
+import { BCMR } from "./Bcmr.js";
+import { FeePaidByEnum, WalletTypeEnum } from "./enum.js";
+import { fromUtxoId, OpReturnData, SendRequest, SendResponse, TokenSendRequest, } from "./model.js";
+import { Util } from "./Util.js";
+const placeholderPrivateKey = "0000000000000000000000000000000000000000000000000000000000000001";
 /**
  * A class to hold features used by all wallets
  * @class  BaseWallet
  */
 export class BaseWallet {
+    get networkPrefix() {
+        return prefixFromNetworkMap[this.network];
+    }
+    // interface to util functions. see Util.ts
+    get util() {
+        if (!this._util) {
+            this._util = new Util(this.network);
+        }
+        return this._util;
+    }
+    // interface to util util. see Util.Util
+    static get util() {
+        return new this().util;
+    }
+    // Return wallet info
+    getInfo() {
+        return {
+            cashaddr: this.cashaddr,
+            tokenaddr: this.tokenaddr,
+            isTestnet: this.isTestnet,
+            name: this.name,
+            network: this.network,
+            publicKeyHash: binToHex(this.publicKeyHash),
+            walletId: this.toString(),
+            walletDbEntry: this.toDbString(),
+        };
+    }
+    slpSemiAware(value = true) {
+        this._slpSemiAware = value;
+        return this;
+    }
     //#region Accessors
     getNetworkProvider(
     // @ts-ignore
     network = NetworkType.Mainnet) {
-        throw Error("getNetworkProvider called on base wallet");
+        return getNetworkProvider(network);
     }
     /**
      * getDepositAddress - get a wallet deposit address
@@ -23,89 +70,32 @@ export class BaseWallet {
      * @returns The deposit address as a string
      */
     getDepositAddress() {
-        return this.address;
+        return this.cashaddr;
     }
     /**
-     * getDepositQr - get an address qrcode, encoded for display on the web
-     *
-     * a high-level function
+     * getTokenDepositAddress - get a cashtoken aware wallet deposit address
      *
-     * @see {@link https://rest-unstable.mainnet.cash/api-docs/#/wallet/depositQr|/wallet/deposit_qr} for REST endpoint
-     *
-     * @returns The qrcode for the address
+     * @returns The cashtoken aware deposit address as a string
      */
-    getDepositQr() {
-        return qrAddress(this.getDepositAddress());
-    }
-    // Get mnemonic and derivation path for wallet
-    getSeed() {
-        if (!this.mnemonic) {
-            throw Error("Wallet mnemonic seed phrase not set");
-        }
-        if (!this.derivationPath) {
-            throw Error("Wallet derivation path not set");
-        }
-        return {
-            seed: this.mnemonic,
-            derivationPath: this.derivationPath,
-            parentDerivationPath: this.parentDerivationPath,
-        };
+    getTokenDepositAddress() {
+        return this.tokenaddr;
     }
     //#endregion Accessors
     //#region Constructors and Statics
     /**
      * constructor for a new wallet
-     * @param {string} name              name of the wallet
      * @param network              network for wallet
      *
      * @throws {Error} if called on BaseWallet
      */
-    constructor(name = "", network = NetworkType.Mainnet, walletType = WalletTypeEnum.Seed) {
-        this.derivationPath = "m/44'/0'/0'/0/0";
-        this.parentDerivationPath = "m/44'/0'/0'";
-        this.name = name;
+    constructor(network = NetworkType.Mainnet) {
+        this._slpSemiAware = false; // a flag which requires an utxo to have more than 546 sats to be spendable and counted in the balance
+        this.name = "";
         this.network = network;
-        this.walletType = walletType;
+        this.walletType = WalletTypeEnum.Watch;
         this.provider = this.getNetworkProvider(this.network);
         this.isTestnet = this.network === NetworkType.Mainnet ? false : true;
     }
-    /**
-     * fromId - create a wallet from encoded walletId string
-     *
-     * @param walletId   walletId options to steer the creation process
-     *
-     * @returns wallet instantiated accordingly to the walletId rules
-     */
-    static async fromId(walletId) {
-        return new this().fromId(walletId);
-    }
-    /**
-     * fromSeed - create a wallet using the seed phrase and derivation path
-     *
-     * unless specified the derivation path m/44'/245'/0'/0/0 will be userd
-     * this derivation path is standard for Electron Cash SLP and other SLP enabled wallets
-     *
-     * @param seed   BIP39 12 word seed phrase
-     * @param derivationPath BIP44 HD wallet derivation path to get a single the private key from hierarchy
-     *
-     * @returns instantiated wallet
-     */
-    static async fromSeed(seed, derivationPath) {
-        return new this().fromSeed(seed, derivationPath);
-    }
-    /**
-     * newRandom - create a random wallet
-     *
-     * if `name` parameter is specified, the wallet will also be persisted to DB
-     *
-     * @param name   user friendly wallet alias
-     * @param dbName name under which the wallet will be stored in the database
-     *
-     * @returns instantiated wallet
-     */
-    static async newRandom(name = "", dbName) {
-        return new this().newRandom(name, dbName);
-    }
     /**
      * watchOnly - create a watch-only wallet
      *
@@ -119,117 +109,7 @@ export class BaseWallet {
     static async watchOnly(address) {
         return new this().watchOnly(address);
     }
-    /**
-     * named - create a named wallet
-     *
-     * @param name   user friendly wallet alias
-     * @param dbName name under which the wallet will be stored in the database
-     * @param force  force recreate wallet in the database if a record already exist
-     *
-     * @returns instantiated wallet
-     */
-    static async named(name, dbName, force) {
-        return new this().named(name, dbName, force);
-    }
-    /**
-     * replaceNamed - replace (recover) named wallet with a new walletId
-     *
-     * If wallet with a provided name does not exist yet, it will be created with a `walletId` supplied
-     * If wallet exists it will be overwritten without exception
-     *
-     * @param name   user friendly wallet alias
-     * @param walletId walletId options to steer the creation process
-     * @param dbName name under which the wallet will be stored in the database
-     *
-     * @returns instantiated wallet
-     */
-    static async replaceNamed(name, walletId, dbName) {
-        return new this().replaceNamed(name, walletId, dbName);
-    }
-    /**
-     * namedExists - check if a named wallet already exists
-     *
-     * @param name   user friendly wallet alias
-     * @param dbName name under which the wallet will be stored in the database
-     *
-     * @returns boolean
-     */
-    static async namedExists(name, dbName) {
-        return new this().namedExists(name, dbName);
-    }
     //#endregion Constructors
-    //#region Protected implementations
-    /**
-     * generate creates a new wallet
-     * @throws {Error} if called on BaseWallet
-     */
-    generate() {
-        throw Error("generate called on base wallet");
-    }
-    /**
-     * fromId - creates a wallet from serialized string
-     *
-     * @throws {Error} if called on BaseWallet
-     */
-    fromId(walletId) {
-        let [walletType, networkGiven, arg1, arg2] = walletId.split(":");
-        if (this.network != networkGiven) {
-            throw Error(`Network prefix ${networkGiven} to a ${this.network} wallet`);
-        }
-        switch (walletType) {
-            case "watch":
-                if (arg2) {
-                    // watch:testnet:bchtest:qq1234567
-                    return this.watchOnly(`${arg1}:${arg2}`);
-                }
-                // watch:testnet:qq1234567
-                return this.watchOnly(`${arg1}`);
-            case "named":
-                if (arg2) {
-                    // named:testnet:wallet_1:my_database
-                    return this.named(arg1, arg2);
-                }
-                else {
-                    // named:testnet:wallet_1
-                    return this.named(arg1);
-                }
-            case "seed":
-                if (arg2) {
-                    // seed:testnet:table later ... stove kitten pluck:m/44'/0'/0'/0/0
-                    return this.fromSeed(arg1, arg2);
-                }
-                // seed:testnet:table later ... stove kitten pluck
-                return this.fromSeed(arg1);
-            default:
-                throw Error(`Unknown wallet type '${walletType}'`);
-        }
-    }
-    // Initialize wallet from a mnemonic phrase
-    async fromSeed(
-    // @ts-ignore
-    mnemonic, 
-    // @ts-ignore
-    derivationPath) {
-        throw Error("fromSeed called on base wallet");
-    }
-    /**
-     * newRandom (internal) if the wallet is named, get or create it; otherwise create a random
-     * unnamed wallet
-     * @param {string} name              name of the wallet
-     * @param {string} dbName            database name the wallet is stored in
-     */
-    async newRandom(name, dbName) {
-        if (name.length > 0) {
-            return this.named(name, dbName);
-        }
-        else {
-            return this.generate();
-        }
-    }
-    // @ts-ignore
-    async watchOnly(address) {
-        throw Error("fromSeed called on base wallet");
-    }
     /**
      * named (internal) get a named wallet from the database or create a new one.
      * Note: this function should behave identically if
@@ -247,23 +127,23 @@ export class BaseWallet {
         }
         _checkContextSafety(this);
         this.name = name;
-        dbName = dbName ? dbName : this.network;
-        let db = getStorageProvider(dbName);
+        dbName = dbName ? dbName : prefixFromNetworkMap[this.network];
+        const db = getStorageProvider(dbName);
         // If there is a database, force saving or error
         if (db) {
             await db.init();
-            let savedWalletRecord = await db.getWallet(name);
+            const savedWalletRecord = await db.getWallet(name);
             if (savedWalletRecord) {
                 await db.close();
                 if (forceNew) {
                     throw Error(`A wallet with the name ${name} already exists in ${dbName}`);
                 }
-                let recoveredWallet = await this.fromId(savedWalletRecord.wallet);
+                const recoveredWallet = await this.fromId(savedWalletRecord.wallet);
                 recoveredWallet.name = savedWalletRecord.name;
                 return recoveredWallet;
             }
             else {
-                let wallet = await this.generate();
+                const wallet = await this.generate();
                 await db.addWallet(wallet.name, wallet.toDbString());
                 await db.close();
                 return wallet;
@@ -291,7 +171,7 @@ export class BaseWallet {
         }
         _checkContextSafety(this);
         this.name = name;
-        dbName = dbName ? dbName : this.network;
+        dbName = dbName ? dbName : prefixFromNetworkMap[this.network];
         let db = getStorageProvider(dbName);
         if (db) {
             await db.init();
@@ -323,7 +203,7 @@ export class BaseWallet {
             throw Error("Named wallets must have a non-empty name");
         }
         _checkContextSafety(this);
-        dbName = dbName ? dbName : this.network;
+        dbName = dbName ? dbName : prefixFromNetworkMap[this.network];
         let db = getStorageProvider(dbName);
         if (db) {
             await db.init();
@@ -335,7 +215,9 @@ export class BaseWallet {
             throw Error("No database was available or configured to store the named wallet.");
         }
     }
-    //#endregion Protected implementations
+    async generate() {
+        return this;
+    }
     //#region Serialization
     /**
      * toDbString - store the serialized version of the wallet in the database, not just the name
@@ -343,47 +225,1008 @@ export class BaseWallet {
      * @throws {Error} if called on BaseWallet
      */
     toDbString() {
-        if (this.walletType == WalletTypeEnum.Seed) {
-            return `${this.walletType}:${this.network}:${this.mnemonic}:${this.derivationPath}`;
-        }
-        else if (this.walletType == WalletTypeEnum.Watch) {
-            return `${this.walletType}:${this.network}:${this.getDepositAddress()}`;
-        }
-        return "";
+        return `${this.walletType}:${this.network}:${this.getDepositAddress()}`;
     }
     // Returns the serialized wallet as a string
     // If storing in a database, set asNamed to false to store secrets
     // In all other cases, the a named wallet is deserialized from the database
     //  by the name key
     toString() {
-        if (this.name) {
-            return `named:${this.network}:${this.name}`;
+        return `${this.walletType}:${this.network}:${this.getDepositAddress()}`;
+    }
+    //#endregion Serialization
+    /**
+     *  explorerUrl   Web url to a transaction on a block explorer
+     *
+     * @param txId   transaction Id
+     * @returns   Url string
+     */
+    explorerUrl(txId) {
+        const explorerUrlMap = {
+            mainnet: "https://blockchair.com/bitcoin-cash/transaction/",
+            testnet: "https://www.blockchain.com/bch-testnet/tx/",
+            regtest: "",
+        };
+        return explorerUrlMap[this.network] + txId;
+    }
+    // returns the public key hash for an address
+    getPublicKeyHash(hex = false) {
+        if (this.publicKeyHash) {
+            return hex ? binToHex(this.publicKeyHash) : this.publicKeyHash;
         }
-        else if (this.walletType == WalletTypeEnum.Seed) {
-            return `${this.walletType}:${this.network}:${this.mnemonic}:${this.derivationPath}`;
+        else {
+            throw Error("The public key hash for this wallet is not known. If this wallet was created from the constructor directly, calling the deriveInfo() function may help. ");
         }
-        else if (this.walletType == WalletTypeEnum.Watch) {
-            return `${this.walletType}:${this.network}:${this.getDepositAddress()}`;
+    }
+    /**
+     * fromCashaddr - 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   cashaddress of a wallet
+     *
+     * @returns instantiated wallet
+     */
+    static async fromCashaddr(address) {
+        const prefix = derivePrefix(address);
+        const networkType = networkPrefixMap[prefix];
+        return new this(networkType).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).watchOnly(address);
+    }
+    /**
+     * named - create a named wallet
+     *
+     * @param name   user friendly wallet alias
+     * @param dbName name under which the wallet will be stored in the database
+     * @param force  force recreate wallet in the database if a record already exist
+     *
+     * @returns instantiated wallet
+     */
+    static async named(name, dbName, force) {
+        return new this().named(name, dbName, force);
+    }
+    /**
+     * replaceNamed - replace (recover) named wallet with a new walletId
+     *
+     * If wallet with a provided name does not exist yet, it will be created with a `walletId` supplied
+     * If wallet exists it will be overwritten without exception
+     *
+     * @param name   user friendly wallet alias
+     * @param walletId walletId options to steer the creation process
+     * @param dbName name under which the wallet will be stored in the database
+     *
+     * @returns instantiated wallet
+     */
+    static async replaceNamed(name, walletId, dbName) {
+        return new this().replaceNamed(name, walletId, dbName);
+    }
+    /**
+     * namedExists - check if a named wallet already exists
+     *
+     * @param name   user friendly wallet alias
+     * @param dbName name under which the wallet will be stored in the database
+     *
+     * @returns boolean
+     */
+    static async namedExists(name, dbName) {
+        return new this().namedExists(name, dbName);
+    }
+    fromId(walletId) {
+        const [walletType, networkGiven, arg1, arg2] = walletId.split(":");
+        if (walletType !== WalletTypeEnum.Watch) {
+            throw Error(`fromId called on a ${walletType} wallet, expected a ${WalletTypeEnum.Watch} wallet`);
+        }
+        if (this.network != networkGiven) {
+            throw Error(`Network prefix ${networkGiven} to a ${this.network} wallet`);
         }
-        return "";
+        if (arg2) {
+            return this.watchOnly(`${arg1}:${arg2}`);
+        }
+        return this.watchOnly(arg1);
+    }
+    // Initialize a watch only wallet from a cash addr
+    async watchOnly(address) {
+        this.walletType = WalletTypeEnum.Watch;
+        const addressComponents = address.split(":");
+        let addressPrefix;
+        let addressBase;
+        if (addressComponents.length === 1) {
+            addressBase = addressComponents.shift();
+            addressPrefix = derivePrefix(addressBase);
+        }
+        else {
+            addressPrefix = addressComponents.shift();
+            addressBase = addressComponents.shift();
+            if (addressPrefix in networkPrefixMap) {
+                if (networkPrefixMap[addressPrefix] !== this.network) {
+                    throw Error(`a ${addressPrefix} address cannot be watched from a ${this.network} Wallet`);
+                }
+            }
+        }
+        const prefixedAddress = `${addressPrefix}:${addressBase}`;
+        // check if a token aware address was provided
+        const addressData = decodeCashAddress(prefixedAddress);
+        if (typeof addressData === "string")
+            throw addressData;
+        this.publicKeyHash = addressData.payload;
+        let nonTokenAwareType = addressData.type;
+        if (nonTokenAwareType == CashAddressType.p2pkhWithTokens)
+            nonTokenAwareType = CashAddressType.p2pkh;
+        if (nonTokenAwareType == CashAddressType.p2shWithTokens)
+            nonTokenAwareType = CashAddressType.p2sh;
+        if (nonTokenAwareType == CashAddressType.p2pkh)
+            this.publicKeyHash = addressData.payload;
+        this.cashaddr = encodeCashAddress({
+            prefix: addressData.prefix,
+            type: nonTokenAwareType,
+            payload: addressData.payload,
+        }).address;
+        this.tokenaddr = deriveTokenaddr(addressData.payload, this.networkPrefix);
+        return this;
     }
-    //#endregion Serialization
     //#region Funds
-    // @ts-ignore
-    async getBalance(rawUnit) {
-        throw Error("sendMax called on base wallet");
+    /**
+     * utxos Get unspent outputs for the wallet
+     *
+     */
+    async getUtxos() {
+        if (!this.cashaddr) {
+            throw Error("Attempted to get utxos without an address");
+        }
+        return await this.getAddressUtxos(this.cashaddr);
     }
-    // @ts-ignore
-    async getMaxAmountToSend(params) {
-        throw Error("getMaxAmountToSend called on base wallet");
+    // gets wallet balance in sats, bch and currency
+    async getBalance(rawUnit, priceCache = true) {
+        if (rawUnit) {
+            const unit = sanitizeUnit(rawUnit);
+            return await balanceFromSatoshi(await this.getBalanceFromProvider(), unit, priceCache);
+        }
+        else {
+            return await balanceResponseFromSatoshi(await this.getBalanceFromProvider(), priceCache);
+        }
     }
-    // @ts-ignore
+    // Gets balance by summing value in all utxos in stats
+    async getBalanceFromUtxos() {
+        const utxos = (await this.getAddressUtxos(this.cashaddr)).filter((val) => val.token === undefined);
+        return sumUtxoValue(utxos);
+    }
+    // Gets balance from fulcrum
+    async getBalanceFromProvider() {
+        // 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();
+    }
+    async getAddressUtxos(address) {
+        if (!address) {
+            address = this.cashaddr;
+        }
+        if (this._slpSemiAware) {
+            const bchUtxos = await this.provider.getUtxos(address);
+            return bchUtxos.filter((bchutxo) => bchutxo.satoshis > DUST_UTXO_THRESHOLD);
+        }
+        else {
+            return await this.provider.getUtxos(address);
+        }
+    }
+    // watching for any transaction hash of this wallet
+    async watchAddress(callback) {
+        return this.provider.watchAddress(this.getDepositAddress(), callback);
+    }
+    // watching for any transaction of this wallet
+    async watchAddressTransactions(callback) {
+        return this.provider.watchAddressTransactions(this.getDepositAddress(), callback);
+    }
+    // watching for cashtoken transaction of this wallet
+    async watchAddressTokenTransactions(callback) {
+        return this.provider.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
+    async watchBalance(callback) {
+        return this.provider.watchAddressStatus(this.getDepositAddress(), async (_status) => {
+            const balance = (await this.getBalance());
+            callback(balance);
+        });
+    }
+    // sets up a callback to be called upon wallet's BCH or USD balance change
+    // if BCH balance does not change, the callback will be triggered every
+    // @param `usdPriceRefreshInterval` milliseconds by polling for new BCH USD price
+    // Since we want to be most sensitive to usd value change, we do not use the cached exchange rates
+    // can be cancelled by calling the function returned from this one
+    async watchBalanceUsd(callback, usdPriceRefreshInterval = 30000) {
+        let usdPrice = -1;
+        const _callback = async () => {
+            const balance = (await this.getBalance(undefined, false));
+            if (usdPrice !== balance.usd) {
+                usdPrice = balance.usd;
+                callback(balance);
+            }
+        };
+        const watchCancel = await this.provider.watchAddressStatus(this.getDepositAddress(), _callback);
+        const interval = setInterval(_callback, usdPriceRefreshInterval);
+        return async () => {
+            await watchCancel?.();
+            clearInterval(interval);
+        };
+    }
+    // waits for address balance to be greater than or equal to the target value
+    // this call halts the execution
+    async waitForBalance(value, rawUnit = UnitEnum.BCH) {
+        return new Promise(async (resolve) => {
+            let watchCancel;
+            watchCancel = await this.watchBalance(async (balance) => {
+                const satoshiBalance = await amountInSatoshi(value, rawUnit);
+                if (balance.sat >= satoshiBalance) {
+                    await watchCancel?.();
+                    resolve(balance);
+                }
+            });
+        });
+    }
+    // sets up a callback to be called upon wallet's token balance change
+    // can be cancelled by calling the function returned from this one
+    async watchTokenBalance(tokenId, callback) {
+        let previous = undefined;
+        return await 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) => {
+            let watchCancel;
+            watchCancel = await 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: {},
+    }) {
+        if (!params.privateKey && params.options?.buildUnsigned !== true) {
+            throw Error("Couldn't get network or private key for wallet.");
+        }
+        if (!this.cashaddr) {
+            throw Error("attempted to send without a cashaddr");
+        }
+        if (params.options && params.options.slpSemiAware) {
+            this._slpSemiAware = true;
+        }
+        let feePaidBy;
+        if (params.options && params.options.feePaidBy) {
+            feePaidBy = params.options.feePaidBy;
+        }
+        else {
+            feePaidBy = FeePaidByEnum.change;
+        }
+        // get inputs
+        let utxos;
+        if (params.options && params.options.utxoIds) {
+            utxos = await checkUtxos(params.options.utxoIds.map((utxoId) => typeof utxoId === "string" ? fromUtxoId(utxoId) : utxoId), this);
+        }
+        else {
+            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();
+        // simulate outputs using the sender's address
+        const sendRequest = new SendRequest({
+            cashaddr: this.cashaddr,
+            value: 100,
+            unit: "sat",
+        });
+        const sendRequests = Array(params.outputCount)
+            .fill(0)
+            .map(() => sendRequest);
+        const fundingUtxos = await getSuitableUtxos(utxos, undefined, bestHeight, feePaidBy, sendRequests);
+        const relayFeePerByteInSatoshi = await getRelayFeeCache(this.provider);
+        const fee = await getFeeAmountSimple({
+            utxos: fundingUtxos,
+            sendRequests: sendRequests,
+            privateKey: params.privateKey ?? hexToBin(placeholderPrivateKey),
+            sourceAddress: this.cashaddr,
+            relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
+            feePaidBy: feePaidBy,
+        });
+        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);
+    }
+    /**
+     * send Send some amount to an address
+     * this function processes the send requests, encodes the transaction, sends it to the network
+     * @returns (depending on the options parameter) the transaction id, new address balance and a link to the transaction on the blockchain explorer
+     *
+     * This is a first class function with REST analog, maintainers should strive to keep backward-compatibility
+     *
+     */
     async send(requests, options) {
-        throw Error("send called on base wallet");
+        const { encodedTransaction, tokenIds, sourceOutputs } = await this.encodeTransaction(requests, undefined, 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);
+            if (options?.queryBalance === undefined ||
+                options?.queryBalance === true) {
+                resp.balance = (await this.getBalance());
+            }
+        }
+        else {
+            resp.unsignedTransaction = binToHex(encodedTransaction);
+            resp.sourceOutputs = sourceOutputs;
+        }
+        return resp;
     }
-    // @ts-ignore
-    async sendMax(address, options) {
-        throw Error("sendMax called on base wallet");
+    /**
+     * sendMax Send all available funds to a destination cash address
+     *
+     * @param  {string} cashaddr destination cash address
+     * @param  {SendRequestOptionsI} options Options of the send requests
+     *
+     * @returns (depending on the options parameter) the transaction id, new address balance and a link to the transaction on the blockchain explorer
+     */
+    async sendMax(cashaddr, options) {
+        return await this.sendMaxRaw(cashaddr, options);
+    }
+    /**
+     * sendMaxRaw (internal) Send all available funds to a destination cash address
+     *
+     * @param  {string} cashaddr destination cash address
+     * @param  {SendRequestOptionsI} options Options of the send requests
+     *
+     * @returns the transaction id sent to the network
+     */
+    async sendMaxRaw(cashaddr, options, privateKey) {
+        const { value: maxSpendableAmount, utxos } = await this._getMaxAmountToSend({
+            outputCount: 1,
+            options: options,
+            privateKey: privateKey,
+        });
+        if (!options) {
+            options = {};
+        }
+        options.utxoIds = utxos;
+        const sendRequest = new SendRequest({
+            cashaddr: cashaddr,
+            value: maxSpendableAmount,
+            unit: "sat",
+        });
+        const { encodedTransaction, tokenIds, sourceOutputs } = await this.encodeTransaction([sendRequest], true, options, privateKey);
+        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);
+            if (options?.queryBalance === undefined ||
+                options?.queryBalance === true) {
+                resp.balance = (await this.getBalance());
+            }
+        }
+        else {
+            resp.unsignedTransaction = binToHex(encodedTransaction);
+            resp.sourceOutputs = sourceOutputs;
+        }
+        return resp;
+    }
+    /**
+     * encodeTransaction Encode and sign a transaction given a list of sendRequests, options and estimate fees.
+     * @param  {SendRequest[]} sendRequests SendRequests
+     * @param  {boolean} discardChange=false
+     * @param  {SendRequestOptionsI} options Options of the send requests
+     */
+    async encodeTransaction(requests, discardChange = false, options, privateKey) {
+        let sendRequests = asSendRequestObject(requests);
+        if (!privateKey && options?.buildUnsigned !== true) {
+            throw new Error(`Missing private key`);
+        }
+        if (options && options.slpSemiAware) {
+            this._slpSemiAware = true;
+        }
+        let feePaidBy;
+        if (options && options.feePaidBy) {
+            feePaidBy = options.feePaidBy;
+        }
+        else {
+            feePaidBy = FeePaidByEnum.change;
+        }
+        let changeAddress;
+        if (options && options.changeAddress) {
+            changeAddress = options.changeAddress;
+        }
+        else {
+            changeAddress = this.cashaddr;
+        }
+        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 = await checkUtxos(options.utxoIds.map((utxoId) => typeof utxoId === "string" ? fromUtxoId(utxoId) : utxoId), this);
+        }
+        else {
+            utxos = await this.getAddressUtxos(this.cashaddr);
+        }
+        // filter out token utxos if there are no token requests
+        if (checkTokenQuantities &&
+            !sendRequests.some((val) => val instanceof TokenSendRequest)) {
+            utxos = utxos.filter((val) => !val.token);
+        }
+        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, 0n);
+                const tokenOutputs = allTokenOutputs.filter((val) => val.tokenId === tokenId);
+                const outputAmountSum = tokenOutputs.reduce((prev, cur) => prev + cur.amount, 0n);
+                const diff = inputAmountSum - outputAmountSum;
+                if (diff < 0) {
+                    throw new Error("Not enough token amount to send");
+                }
+                if (diff >= 0) {
+                    let available = 0n;
+                    let change = 0n;
+                    const ensureUtxos = [];
+                    for (const token of tokenInputs.filter((val) => val.token?.amount)) {
+                        ensureUtxos.push(token);
+                        available += token.token.amount;
+                        if (available >= outputAmountSum) {
+                            change = available - outputAmountSum;
+                            //break;
+                        }
+                    }
+                    if (ensureUtxos.length) {
+                        if (!options) {
+                            options = {};
+                        }
+                        options.ensureUtxos = [
+                            ...(options.ensureUtxos ?? []),
+                            ...ensureUtxos,
+                        ].filter((val, index, array) => array.findIndex((other) => other.txid === val.txid && other.vout === val.vout) === index);
+                    }
+                    if (change > 0) {
+                        outputs.push(new TokenSendRequest({
+                            cashaddr: toTokenaddr(changeAddress) || this.tokenaddr,
+                            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) {
+            throw Error("There were no Unspent Outputs");
+        }
+        if (typeof spendAmount !== "bigint") {
+            throw Error("Couldn't get spend amount when building transaction");
+        }
+        const relayFeePerByteInSatoshi = await getRelayFeeCache(this.provider);
+        const feeEstimate = await getFeeAmountSimple({
+            utxos: utxos,
+            sendRequests: sendRequests,
+            privateKey: privateKey ?? hexToBin(placeholderPrivateKey),
+            sourceAddress: this.cashaddr,
+            relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
+            feePaidBy: feePaidBy,
+        });
+        const fundingUtxos = await getSuitableUtxos(utxos, BigInt(spendAmount) + BigInt(Math.ceil(feeEstimate)), bestHeight, feePaidBy, sendRequests, options?.ensureUtxos || [], options?.tokenOperation);
+        if (fundingUtxos.length === 0) {
+            throw Error("The available inputs couldn't satisfy the request with fees");
+        }
+        const fee = await getFeeAmount({
+            utxos: fundingUtxos,
+            sendRequests: sendRequests,
+            privateKey: privateKey ?? hexToBin(placeholderPrivateKey),
+            sourceAddress: this.cashaddr,
+            relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
+            feePaidBy: feePaidBy,
+        });
+        const { encodedTransaction, sourceOutputs } = await buildEncodedTransaction({
+            inputs: fundingUtxos,
+            outputs: sendRequests,
+            signingKey: privateKey ?? hexToBin(placeholderPrivateKey),
+            sourceAddress: this.cashaddr,
+            fee,
+            discardChange,
+            feePaidBy,
+            changeAddress,
+            buildUnsigned: options?.buildUnsigned === true,
+        });
+        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, sourceOutputs };
+    }
+    // Submit a raw transaction
+    async submitTransaction(transaction, awaitPropagation = true) {
+        if (!this.provider) {
+            throw Error("Wallet network provider was not initialized");
+        }
+        let rawTransaction = binToHex(transaction);
+        return await this.provider.sendRawTransaction(rawTransaction, awaitPropagation);
+    }
+    // gets transaction history of this wallet
+    async getRawHistory(fromHeight = 0, toHeight = -1) {
+        return await this.provider.getHistory(this.cashaddr, fromHeight, toHeight);
+    }
+    /**
+     * getHistory gets transaction history of this wallet with most data decoded and ready to present to user
+     * @note balance calculations are valid only if querying to the blockchain tip (`toHeight` === -1, `count` === -1)
+     * @note this method is heavy on network calls, if invoked in browser use of cache is advised, @see `Config.UseLocalStorageCache`
+     * @note this method tries to recreate the history tab view of Electron Cash wallet, however, it may not be 100% accurate if the tnransaction value changes are the same in the same block (ordering)
+     *
+     * @param unit optional, BCH or currency unit to present balance and balance changes. If unit is currency like USD or EUR, balances will be subject to possible rounding errors. Default 0
+     * @param fromHeight optional, if set, history will be limited. Default 0
+     * @param toHeight optional, if set, history will be limited. Default -1, meaning that all history items will be returned, including mempool
+     * @param start optional, if set, the result set will be paginated with offset `start`
+     * @param count optional, if set, the result set will be paginated with `count`. Default -1, meaning that all history items will be returned
+     *
+     * @returns an array of transaction history items, with input values and addresses encoded in cashaddress format. @see `TransactionHistoryItem` type
+     */
+    async getHistory({ unit = "sat", fromHeight = 0, toHeight = -1, start = 0, count = -1, }) {
+        return getAddressHistory({
+            address: this.cashaddr,
+            provider: this.provider,
+            unit,
+            fromHeight,
+            toHeight,
+            start,
+            count,
+        });
+    }
+    // gets last transaction of this wallet
+    async getLastTransaction(confirmedOnly = false) {
+        let history = await this.getRawHistory();
+        if (confirmedOnly) {
+            history = history.filter((val) => val.height > 0);
+        }
+        if (!history.length) {
+            return null;
+        }
+        const [lastTx] = history.slice(-1);
+        return this.provider.getRawTransactionObject(lastTx.tx_hash);
+    }
+    // waits for next transaction, program execution is halted
+    async waitForTransaction(options = {
+        getTransactionInfo: true,
+        getBalance: false,
+        txHash: undefined,
+    }) {
+        if (options.getTransactionInfo === undefined) {
+            options.getTransactionInfo = true;
+        }
+        return new Promise(async (resolve) => {
+            let txHashSeen = false;
+            const makeResponse = async (txHash) => {
+                const response = {};
+                const promises = [undefined, undefined];
+                if (options.getBalance === true) {
+                    promises[0] = this.getBalance();
+                }
+                if (options.getTransactionInfo === true) {
+                    if (!txHash) {
+                        promises[1] = this.getLastTransaction();
+                    }
+                    else {
+                        promises[1] = this.provider.getRawTransactionObject(txHash);
+                    }
+                }
+                const result = await Promise.all(promises);
+                response.balance = result[0];
+                response.transactionInfo = result[1];
+                return response;
+            };
+            // waiting for a specific transaction to propagate
+            if (options.txHash) {
+                let cancel;
+                const waitForTransactionCallback = async (data) => {
+                    if (data && data[0] === options.txHash && data[1] !== null) {
+                        txHashSeen = true;
+                        await cancel?.();
+                        resolve(makeResponse(options.txHash));
+                    }
+                };
+                cancel = await this.provider.subscribeToTransaction(options.txHash, waitForTransactionCallback);
+                return;
+            }
+            // waiting for any address transaction
+            let watchCancel;
+            let initialResponseSeen = false;
+            watchCancel = await this.provider.watchAddressStatus(this.getDepositAddress(), async (_status) => {
+                if (initialResponseSeen) {
+                    await watchCancel?.();
+                    resolve(makeResponse());
+                    return;
+                }
+                initialResponseSeen = true;
+            });
+        });
+    }
+    /**
+     * watchBlocks Watch network blocks
+     *
+     * @param callback callback with a block header object
+     * @param skipCurrentHeight if set, the notification about current block will not arrive
+     *
+     * @returns a function which will cancel watching upon evaluation
+     */
+    async watchBlocks(callback, skipCurrentHeight = true) {
+        return this.provider.watchBlocks(callback, skipCurrentHeight);
+    }
+    /**
+     * waitForBlock Wait for a network block
+     *
+     * @param height if specified waits for this exact blockchain height, otherwise resolves with the next block
+     *
+     */
+    async waitForBlock(height) {
+        return this.provider.waitForBlock(height);
+    }
+    //#endregion Funds
+    // Convenience wrapper to verify interface
+    async verify(message, sig, publicKey) {
+        return await new SignedMessage().verify(message, sig, this.cashaddr, publicKey);
+    }
+    //#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
+     * @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
+     */
+    async tokenGenesis(genesisRequest, sendRequests = [], options) {
+        if (!Array.isArray(sendRequests)) {
+            sendRequests = [sendRequests];
+        }
+        let utxos;
+        if (options && options.utxoIds) {
+            utxos = await checkUtxos(options.utxoIds.map((utxoId) => typeof utxoId === "string" ? fromUtxoId(utxoId) : utxoId), this);
+        }
+        else {
+            utxos = await this.getAddressUtxos(this.cashaddr);
+        }
+        const genesisInputs = utxos.filter((val) => val.vout === 0 && !val.token);
+        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: genesisInputs[0].txid,
+        });
+        return this.send([genesisSendRequest, ...sendRequests], {
+            ...options,
+            utxoIds: utxos,
+            ensureUtxos: [genesisInputs[0]],
+            checkTokenQuantities: false,
+            queryBalance: false,
+            tokenOperation: "genesis",
+        });
+    }
+    /**
+     * 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
+     * @param  {SendRequestOptionsI} options Options of the send requests
+     */
+    async tokenMint(tokenId, mintRequests, deductTokenAmount = false, options) {
+        if (tokenId?.length !== 64) {
+            throw Error(`Invalid tokenId supplied: ${tokenId}`);
+        }
+        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.minting);
+        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 - BigInt(mintRequests.length)
+            : nftUtxos[0].token.amount;
+        const safeNewAmount = newAmount < 0n ? 0n : newAmount;
+        const mintingInput = new TokenSendRequest({
+            cashaddr: this.tokenaddr,
+            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.tokenaddr,
+                amount: 0,
+                tokenId: tokenId,
+                value: val.value,
+                capability: val.capability,
+                commitment: val.commitment,
+            })),
+        ], {
+            ...options,
+            ensureUtxos: [nftUtxos[0]],
+            checkTokenQuantities: false,
+            queryBalance: false,
+            tokenOperation: "mint",
+        });
+    }
+    /**
+     * 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
+     * @param  {SendRequestOptionsI} options Options of the send requests
+     */
+    async tokenBurn(burnRequest, message, options) {
+        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);
+        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 || 0n), 0n);
+        let fungibleBurnAmount = burnRequest.amount && burnRequest.amount > 0 ? burnRequest.amount : 0n;
+        fungibleBurnAmount = BigInt(fungibleBurnAmount);
+        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 === 0n) {
+                changeSendRequests = [];
+                utxoIds.push(tokenUtxos[0]);
+            }
+            else {
+                // add utxos to spend from
+                let available = 0n;
+                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 = newAmount < 0n ? 0n : newAmount;
+                changeSendRequests = [
+                    new TokenSendRequest({
+                        cashaddr: burnRequest.cashaddr || this.tokenaddr,
+                        tokenId: burnRequest.tokenId,
+                        capability: burnRequest.capability,
+                        commitment: burnRequest.commitment,
+                        amount: safeNewAmount,
+                        value: tokenUtxos[0].satoshis,
+                    }),
+                ];
+            }
+        }
+        else {
+            // if we are burning last fungible tokens, let us destroy the token completely
+            if (totalFungibleAmount === fungibleBurnAmount) {
+                changeSendRequests = [];
+                utxoIds.push(...tokenUtxos);
+            }
+            else {
+                // add utxos to spend from
+                let available = 0n;
+                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 = available - fungibleBurnAmount;
+                const safeNewAmount = newAmount < 0n ? 0n : newAmount;
+                changeSendRequests = [
+                    new TokenSendRequest({
+                        cashaddr: burnRequest.cashaddr || this.tokenaddr,
+                        tokenId: burnRequest.tokenId,
+                        amount: safeNewAmount,
+                        value: tokenUtxos.reduce((a, c) => a + c.satoshis, 0),
+                    }),
+                ];
+            }
+        }
+        const opReturn = OpReturnData.fromString(message || "");
+        return this.send([opReturn, ...changeSendRequests], {
+            ...options,
+            checkTokenQuantities: false,
+            queryBalance: false,
+            ensureUtxos: utxoIds.length > 0 ? utxoIds : undefined,
+            tokenOperation: "burn",
+        });
+    }
+    /**
+     * 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.cashaddr);
+        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  {bigint} fungible token balance
+     */
+    async getTokenBalance(tokenId) {
+        const utxos = (await this.getTokenUtxos(tokenId)).filter((val) => val.token?.amount);
+        return sumTokenAmounts(utxos, tokenId);
+    }
+    /**
+     * getNftTokenBalance Gets non-fungible token (NFT) balance for a particular 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)).filter((val) => val.token?.commitment !== undefined);
+        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()).filter((val) => val.token?.amount);
+        for (const utxo of utxos) {
+            if (!result[utxo.token.tokenId]) {
+                result[utxo.token.tokenId] = 0n;
+            }
+            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()).filter((val) => val.token?.commitment !== undefined);
+        for (const utxo of utxos) {
+            if (!result[utxo.token.tokenId]) {
+                result[utxo.token.tokenId] = 0;
+            }
+            result[utxo.token.tokenId] += 1;
+        }
+        return result;
+    }
+}
+/**
+ * Class to manage a mainnet watch wallet.
+ */
+export class WatchWallet extends BaseWallet {
+    static { this.networkPrefix = CashAddressNetworkPrefix.mainnet; }
+    static { this.walletType = WalletTypeEnum.Watch; }
+    constructor() {
+        super(NetworkType.Mainnet);
+    }
+}
+/**
+ * Class to manage a testnet watch wallet.
+ */
+export class TestNetWatchWallet extends BaseWallet {
+    static { this.networkPrefix = CashAddressNetworkPrefix.testnet; }
+    static { this.walletType = WalletTypeEnum.Watch; }
+    constructor() {
+        super(NetworkType.Testnet);
+    }
+}
+/**
+ * Class to manage a regtest watch wallet.
+ */
+export class RegTestWatchWallet extends BaseWallet {
+    static { this.networkPrefix = CashAddressNetworkPrefix.regtest; }
+    static { this.walletType = WalletTypeEnum.Watch; }
+    constructor() {
+        super(NetworkType.Regtest);
     }
 }
 /**