nexa-wallet-sdk 0.1.2

package/dist/index.mjs

@@ -0,0 +1,2456 @@
+import {Networks as $633cp$Networks, HDPrivateKey as $633cp$HDPrivateKey, TransactionBuilder as $633cp$TransactionBuilder, Message as $633cp$Message, AddressType as $633cp$AddressType, Address as $633cp$Address, CommonUtils as $633cp$CommonUtils, UnitUtils as $633cp$UnitUtils, Transaction as $633cp$Transaction, GroupToken as $633cp$GroupToken, ScriptFactory as $633cp$ScriptFactory, Script as $633cp$Script, Output as $633cp$Output} from "libnexa-ts";
+import {generateMnemonic as $633cp$generateMnemonic, wordlists as $633cp$wordlists, mnemonicToSeedSync as $633cp$mnemonicToSeedSync} from "bip39";
+import {isNil as $633cp$isNil, isString as $633cp$isString, isBuffer as $633cp$isBuffer, parseInt as $633cp$parseInt, isArray as $633cp$isArray, isObject as $633cp$isObject} from "lodash-es";
+import {ElectrumClient as $633cp$ElectrumClient} from "@vgrunner/electrum-cash";
+import $633cp$jsbigdecimal from "js-big-decimal";
+
+
+      var $parcel$global = globalThis;
+    // @ts-ignore
+var $bbe36848c5b6746e$exports = {};
+$bbe36848c5b6746e$exports = JSON.parse("{\"name\":\"@nexa/wallet-sdk-ts\",\"version\":\"0.1.0\",\"main\":\"dist/index.js\",\"module\":\"dist/index.mjs\",\"types\":\"dist/index.d.ts\",\"source\":\"src/index.ts\",\"scripts\":{\"build\":\"parcel build\",\"dev\":\"parcel watch\",\"test\":\"vitest run\",\"clean\":\"rm -rf dist .parcel-cache\"},\"repository\":{\"type\":\"git\",\"url\":\"git+ssh://git@gitlab.com/nexa/wallet-sdk-ts.git\"},\"keywords\":[\"nexa\",\"wallet\",\"web3\",\"crypto\",\"dapp\",\"walletcomms\",\"walletsdk\"],\"contributors\":[{\"name\":\"Dolaned\"},{\"name\":\"Griffith\"},{\"name\":\"Vgrunner\"},{\"name\":\"myendy\"}],\"author\":\"Dolaned\",\"license\":\"MIT\",\"bugs\":{\"url\":\"https://gitlab.com/nexa/wallet-sdk-ts/issues\"},\"homepage\":\"https://gitlab.com/nexa/wallet-sdk-ts#readme\",\"description\":\"Wallet SDK for the Nexa blockchain\",\"devDependencies\":{\"@parcel/packager-ts\":\"^2.15.4\",\"@parcel/transformer-typescript-types\":\"^2.15.4\",\"@types/lodash-es\":\"^4.17.12\",\"@types/node\":\"^22.13.1\",\"parcel\":\"^2.15.4\",\"typescript\":\"^5.8.3\",\"vitest\":\"^3.0.8\"},\"targets\":{\"main\":{\"context\":\"node\",\"outputFormat\":\"commonjs\",\"distDir\":\"dist\",\"isLibrary\":true,\"includeNodeModules\":[\"lodash-es\"]},\"module\":{\"context\":\"node\",\"outputFormat\":\"esmodule\",\"distDir\":\"dist\",\"isLibrary\":true},\"browser\":{\"context\":\"browser\",\"outputFormat\":\"esmodule\",\"distDir\":\"dist\",\"isLibrary\":true}},\"dependencies\":{\"@vgrunner/electrum-cash\":\"^2.0.12\",\"bip39\":\"^3.1.0\",\"js-big-decimal\":\"^2.2.0\",\"libnexa-ts\":\"^1.0.5\",\"lodash-es\":\"^4.17.21\"},\"directories\":{\"test\":\"tests\"}}");
+
+
+
+
+
+const $a0b58ced4ea5a401$export$1f6f962b0b96558 = {
+    WS: 'ws',
+    WSS: 'wss'
+};
+
+
+class $30c92dd8e96ca60d$export$ba81aefc89aef50c {
+    constructor(){}
+    async getVersion() {
+        return await this.execute('server.version');
+    }
+    async getBlockTip() {
+        return await this.execute('blockchain.headers.tip');
+    }
+    async getBalance(address) {
+        return await this.execute('blockchain.address.get_balance', address, 'exclude_tokens');
+    }
+    async getTransactionsHistory(address) {
+        return await this.execute('blockchain.address.get_history', address);
+    }
+    async getFirstUse(address) {
+        return await this.execute('blockchain.address.get_first_use', address);
+    }
+    async getTransaction(id, verbose = true) {
+        return await this.execute('blockchain.transaction.get', id, verbose);
+    }
+    async getUtxo(outpoint) {
+        return await this.execute('blockchain.utxo.get', outpoint);
+    }
+    async getNexaUtxos(address) {
+        return await this.execute('blockchain.address.listunspent', address, 'exclude_tokens');
+    }
+    async getTokenUtxos(address, token) {
+        let listunspent = await this.execute('token.address.listunspent', address, null, token);
+        return listunspent.unspent;
+    }
+    async getTokensBalance(address, token) {
+        if (token) return await this.execute('token.address.get_balance', address, null, token);
+        return await this.execute('token.address.get_balance', address);
+    }
+    async getTokenGenesis(token) {
+        return await this.execute('token.genesis.info', token);
+    }
+    async subscribeToAddresses(addresses, callback) {
+        for (const addr of addresses)await this.client?.subscribe(callback, 'blockchain.address.subscribe', addr);
+    }
+    async broadcast(txHex) {
+        return await this.execute('blockchain.transaction.broadcast', txHex);
+    }
+    async getLatency() {
+        try {
+            let start = Date.now();
+            let res = await this.getBlockTip();
+            if (res) return Date.now() - start;
+            return 0;
+        } catch  {
+            return 0;
+        }
+    }
+    async connect(params) {
+        try {
+            if (!params) params = {
+                host: 'aus.electrum.nexa.onethirtyseven.dev',
+                port: 30004,
+                scheme: (0, $a0b58ced4ea5a401$export$1f6f962b0b96558).WSS
+            };
+            this.client = new (0, $633cp$ElectrumClient)("com.otoplo.wallet", "1.4.3", params.host, params.port, params.scheme, 30000, 10000, true);
+            await this.client.connect();
+        } catch (e) {
+            if (e instanceof Error) console.info(e.message);
+            else console.error(e);
+            throw e;
+        }
+    }
+    async disconnect(force) {
+        try {
+            return await this.client.disconnect(force);
+        } catch (e) {
+            console.log(e);
+            return false;
+        }
+    }
+    async execute(method, ...parameters) {
+        var res = await this.client.request(method, ...parameters);
+        if (res instanceof Error) throw res;
+        return res;
+    }
+}
+const $30c92dd8e96ca60d$export$eaa49f0478d81b9d = new $30c92dd8e96ca60d$export$ba81aefc89aef50c();
+
+
+
+
+
+
+
+class $51649cc8d0caebe5$export$c54c8796e94a37a0 {
+    get transactions() {
+        return this._transactions;
+    }
+    set transactions(value) {
+        this._transactions = value;
+    }
+    constructor(_bip44Account){
+        this._tokenBalances = {};
+        this._transactions = new Map();
+        this._bip44Account = _bip44Account;
+        this._balance = {
+            confirmed: 0,
+            unconfirmed: 0
+        };
+        this._tokenBalances = {};
+    }
+    get balance() {
+        return this._balance;
+    }
+    set balance(value) {
+        this._balance = value;
+    }
+    get tokenBalances() {
+        return this._tokenBalances;
+    }
+    set tokenBalances(value) {
+        this._tokenBalances = value;
+    }
+}
+
+
+
+class $5ef3d149a7ae4b51$export$2e2bcd8739ae039 extends (0, $51649cc8d0caebe5$export$c54c8796e94a37a0) {
+    constructor(bip44Account, accountIndex, addressKey){
+        super(bip44Account);
+        this._accountIndex = accountIndex;
+        this._accountKey = addressKey;
+    }
+    // this is used in AccountStore.ts to get the key to be used in the map for this account
+    getAccountStoreKey() {
+        return String(this._bip44Account + '.' + this._accountIndex);
+    }
+    getAccountType() {
+        return (0, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7).DAPP_ACCOUNT;
+    }
+    getNewAddress() {
+        return this._accountKey.address;
+    }
+    getNewChangeAddress() {
+        return this._accountKey.address;
+    }
+    get accountIndexes() {
+        return {
+            rIndex: this._accountIndex,
+            cIndex: 0
+        };
+    }
+    get accountKeys() {
+        return {
+            receiveKeys: [
+                this._accountKey
+            ],
+            changeKeys: [
+                this._accountKey
+            ]
+        };
+    }
+    async loadBalances() {
+        let balances = await (0, $f10b40ff0fa7ccfb$export$9e38d26dbd7c33f4)([
+            this._accountKey
+        ]);
+        let tokenBalances = [
+            this._accountKey
+        ].map((k)=>k.tokensBalance);
+        super.balance = (0, $f10b40ff0fa7ccfb$export$a26005fb5b8d1e4a)(balances);
+        super.tokenBalances = (0, $f10b40ff0fa7ccfb$export$dec515296f176dbe)(tokenBalances);
+    }
+    getKeyFromAddress(address) {
+        return this._accountKey;
+    }
+    async getTransactions(fromHeight, address) {
+        let txPromises = [];
+        const transactions = await (0, $f10b40ff0fa7ccfb$export$a2ed4b531376a5a4)([
+            address ?? this._accountKey.address
+        ], fromHeight ?? 0);
+        for (let tx of transactions.txs.values()){
+            let t = await (0, $f10b40ff0fa7ccfb$export$9c6f4f51acbc89b9)(tx, [
+                address ?? this._accountKey.address
+            ]);
+            txPromises.push(t);
+        }
+        await Promise.all(txPromises);
+        for (let txEntity of txPromises)this.transactions.set(txEntity.txId, txEntity);
+        return this.transactions;
+    }
+}
+
+
+
+
+class $3213756e8a8eb72f$export$2e2bcd8739ae039 extends (0, $51649cc8d0caebe5$export$c54c8796e94a37a0) {
+    constructor(bip44Account, accountIndexes, accountKeys){
+        super(bip44Account);
+        if (accountIndexes.rIndex < 0) throw new Error(`Can not create nexa account with an rindex of ${accountIndexes.rIndex}. must be >= 0.`);
+        if (accountIndexes.cIndex < 0) throw new Error(`Can not create nexa account with an cindex of ${accountIndexes.cIndex}. must be >= 0.`);
+        this._accountIndexes = accountIndexes;
+        this._accountKeys = accountKeys;
+    }
+    // this is used in AccountStore.ts to get the key to be used in the map for this account
+    getAccountStoreKey() {
+        return String(this._bip44Account);
+    }
+    getAccountType() {
+        return (0, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7).NEXA_ACCOUNT;
+    }
+    getNewAddress() {
+        return this._accountKeys.receiveKeys[this._accountKeys.receiveKeys.length - 1]?.address ?? '';
+    }
+    getNewChangeAddress() {
+        return this._accountKeys.changeKeys[this._accountKeys.changeKeys.length - 1]?.address ?? '';
+    }
+    get accountIndexes() {
+        return this._accountIndexes;
+    }
+    get accountKeys() {
+        return this._accountKeys;
+    }
+    async loadBalances() {
+        let balances = await (0, $f10b40ff0fa7ccfb$export$9e38d26dbd7c33f4)(this._accountKeys.receiveKeys.concat(this._accountKeys.changeKeys));
+        let tokenBalances = this._accountKeys.receiveKeys.concat(this._accountKeys.changeKeys).map((k)=>k.tokensBalance);
+        super.balance = (0, $f10b40ff0fa7ccfb$export$a26005fb5b8d1e4a)(balances);
+        super.tokenBalances = (0, $f10b40ff0fa7ccfb$export$dec515296f176dbe)(tokenBalances);
+    }
+    getKeyFromAddress(address) {
+        const allKeys = this._accountKeys.receiveKeys.concat(this._accountKeys.changeKeys);
+        const keyFound = allKeys.find((key)=>key.address === address);
+        return keyFound;
+    }
+    async getTransactions(fromHeight, address) {
+        let receiveAddresses = this.accountKeys.receiveKeys.map((ak)=>ak.address);
+        let changeAddresses = this.accountKeys.changeKeys.map((ak)=>ak.address);
+        let allAddresses = receiveAddresses.concat(changeAddresses);
+        let rTxs = (0, $f10b40ff0fa7ccfb$export$a2ed4b531376a5a4)(address != null ? [
+            address
+        ] : receiveAddresses, fromHeight ?? 0);
+        let cTxs = (0, $f10b40ff0fa7ccfb$export$a2ed4b531376a5a4)(address != null ? [
+            address
+        ] : receiveAddresses, fromHeight ?? 0);
+        let [rData, cData] = await Promise.all([
+            rTxs,
+            cTxs
+        ]);
+        let txHistory = rData.txs;
+        for (let tx of cData.txs.values())txHistory.set(tx.tx_hash, tx);
+        let txPromises = [];
+        for (let tx of txHistory.values()){
+            let t = await (0, $f10b40ff0fa7ccfb$export$9c6f4f51acbc89b9)(tx, allAddresses);
+            txPromises.push(t);
+        }
+        await Promise.all(txPromises);
+        for (let txEntity of txPromises)this.transactions.set(txEntity.txId, txEntity);
+        return this.transactions;
+    }
+}
+
+
+
+
+class $fcf0a0849682f4b5$export$2e2bcd8739ae039 extends (0, $51649cc8d0caebe5$export$c54c8796e94a37a0) {
+    constructor(bip44Account, accountIndex, addressKey){
+        super(bip44Account);
+        this._accountIndex = accountIndex;
+        this._accountKey = addressKey;
+    }
+    // this is used in AccountStore.ts to get the key to be used in the map for this account
+    getAccountStoreKey() {
+        return String(this._bip44Account + '.' + this._accountIndex);
+    }
+    getAccountType() {
+        return (0, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7).VAULT_ACCOUNT;
+    }
+    getNewAddress() {
+        return this._accountKey.address;
+    }
+    getNewChangeAddress() {
+        return this._accountKey.address;
+    }
+    get accountIndexes() {
+        return {
+            rIndex: this._accountIndex,
+            cIndex: 0
+        };
+    }
+    get accountKeys() {
+        return {
+            receiveKeys: [
+                this._accountKey
+            ],
+            changeKeys: [
+                this._accountKey
+            ]
+        };
+    }
+    async loadBalances() {
+        let balances = await (0, $f10b40ff0fa7ccfb$export$9e38d26dbd7c33f4)([
+            this._accountKey
+        ]);
+        let tokenBalances = [
+            this._accountKey
+        ].map((k)=>k.tokensBalance);
+        super.balance = (0, $f10b40ff0fa7ccfb$export$a26005fb5b8d1e4a)(balances);
+        super.tokenBalances = (0, $f10b40ff0fa7ccfb$export$dec515296f176dbe)(tokenBalances);
+    }
+    getKeyFromAddress(address) {
+        return this._accountKey;
+    }
+    async getTransactions(fromHeight, address) {
+        let txPromises = [];
+        const transactions = await (0, $f10b40ff0fa7ccfb$export$a2ed4b531376a5a4)([
+            address ?? this._accountKey.address
+        ], fromHeight ?? 0);
+        for (let tx of transactions.txs.values()){
+            let t = await (0, $f10b40ff0fa7ccfb$export$9c6f4f51acbc89b9)(tx, [
+                address ?? this._accountKey.address
+            ]);
+            txPromises.push(t);
+        }
+        await Promise.all(txPromises);
+        for (let txEntity of txPromises)this.transactions.set(txEntity.txId, txEntity);
+        return this.transactions;
+    }
+}
+
+
+
+
+const $424cf91992355440$export$8ba128bc85947a2a = 9223372036854775807n;
+function $424cf91992355440$export$78d0476e8d098ba7() {
+    return Math.floor(Date.now() / 1000);
+}
+function $424cf91992355440$export$c8733ae29fb53302(arg) {
+    return !arg || arg.length === 0;
+}
+function $424cf91992355440$export$78e516cc94be797b(amount, decimals) {
+    let val = new (0, $633cp$jsbigdecimal)(amount).divide(new (0, $633cp$jsbigdecimal)(Math.pow(10, decimals)), decimals).getPrettyValue();
+    if (val.match(/\./)) val = val.replace(/\.?0+$/, '');
+    return val;
+}
+function $424cf91992355440$export$9ad78026dec58d6(amount, decimals) {
+    return new (0, $633cp$jsbigdecimal)(amount).multiply(new (0, $633cp$jsbigdecimal)(Math.pow(10, decimals))).getValue();
+}
+function $424cf91992355440$export$23010fd5dda8dec1(address) {
+    if ((0, $633cp$CommonUtils).isHexa(address)) return Buffer.from(address, 'hex');
+    return (0, $633cp$Address).fromString(address).data;
+}
+function $424cf91992355440$export$254a5c7330bbfd41(token) {
+    if ((0, $633cp$CommonUtils).isHexa(token)) return token;
+    return $424cf91992355440$export$23010fd5dda8dec1(token).toString('hex');
+}
+
+
+var $f10b40ff0fa7ccfb$export$dcc1fb6ad5308e56 = /*#__PURE__*/ function(TxTokenType) {
+    TxTokenType[TxTokenType["NO_GROUP"] = 0] = "NO_GROUP";
+    TxTokenType[TxTokenType["CREATE"] = 1] = "CREATE";
+    TxTokenType[TxTokenType["MINT"] = 2] = "MINT";
+    TxTokenType[TxTokenType["MELT"] = 3] = "MELT";
+    TxTokenType[TxTokenType["RENEW"] = 4] = "RENEW";
+    TxTokenType[TxTokenType["TRANSFER"] = 5] = "TRANSFER";
+    return TxTokenType;
+}({});
+var $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7 = /*#__PURE__*/ function(AccountType) {
+    AccountType[AccountType["NEXA_ACCOUNT"] = 0] = "NEXA_ACCOUNT";
+    AccountType[AccountType["VAULT_ACCOUNT"] = 1] = "VAULT_ACCOUNT";
+    AccountType[AccountType["DAPP_ACCOUNT"] = 2] = "DAPP_ACCOUNT";
+    return AccountType;
+}({});
+function $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab(address, network, type = (0, $633cp$AddressType).PayToScriptTemplate) {
+    return (0, $633cp$Address).isValid(address, network, type);
+}
+function $f10b40ff0fa7ccfb$export$11f4ae2b4ff9633d(mnemonic, passphrase) {
+    const seed = $633cp$mnemonicToSeedSync(mnemonic, passphrase);
+    const masterKey = (0, $633cp$HDPrivateKey).fromSeed(seed);
+    return masterKey.deriveChild(44, true).deriveChild(29223, true);
+}
+function $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, account) {
+    return masterKey.deriveChild(account, true);
+}
+function $f10b40ff0fa7ccfb$export$d6e8eb22902c6b88(accountKey, fromRIndex, rIndex, fromCIndex, cIndex) {
+    if (fromRIndex < 0) throw new Error(`Can not generate keys with fromRIndex ${fromRIndex}. must be >= 0.`);
+    if (fromCIndex < 0) throw new Error(`Can not generate keys with fromCIndex ${fromCIndex}. must be >= 0.`);
+    let receive = accountKey.deriveChild(0, false);
+    let change = accountKey.deriveChild(1, false);
+    let rKeys = [], cKeys = [];
+    for(let index = fromRIndex; index < rIndex; index++){
+        let k = receive.deriveChild(index, false);
+        let addr = k.privateKey.toAddress().toString();
+        rKeys.push({
+            key: k,
+            address: addr,
+            balance: "0",
+            tokensBalance: {}
+        });
+    }
+    for(let index = fromCIndex; index < cIndex; index++){
+        let k = change.deriveChild(index, false);
+        let addr = k.privateKey.toAddress().toString();
+        cKeys.push({
+            key: k,
+            address: addr,
+            balance: "0",
+            tokensBalance: {}
+        });
+    }
+    return {
+        receiveKeys: rKeys,
+        changeKeys: cKeys
+    };
+}
+function $f10b40ff0fa7ccfb$export$1e0ce394ebe84ca9(accountKey, rIndex) {
+    let receive = accountKey.deriveChild(0, false);
+    let k = receive.deriveChild(rIndex, false);
+    let addr = k.privateKey.toAddress().toString();
+    return {
+        key: k,
+        address: addr,
+        balance: "0",
+        tokensBalance: {}
+    };
+}
+async function $f10b40ff0fa7ccfb$var$discoverUsedAccountIndexes(deriveKey) {
+    let lastUsed = -1, index = 0, toScan = 20;
+    while(toScan > 0){
+        toScan--;
+        let rAddr = deriveKey.deriveChild(index, false).privateKey.toAddress().toString();
+        let isUsed = await $f10b40ff0fa7ccfb$var$isAddressUsed(rAddr);
+        if (isUsed) {
+            lastUsed = index;
+            toScan = 20;
+        }
+        index++;
+    }
+    // return the last used index, returns -1 if no indexes are used
+    return lastUsed;
+}
+async function $f10b40ff0fa7ccfb$export$4aeb2c92e53ab137(accountKey) {
+    let receiveKey = accountKey.deriveChild(0, false);
+    let changeKey = accountKey.deriveChild(1, false);
+    let rIndexPromise = $f10b40ff0fa7ccfb$var$discoverUsedAccountIndexes(receiveKey);
+    let cIndexPromise = $f10b40ff0fa7ccfb$var$discoverUsedAccountIndexes(changeKey);
+    let [rIndex, cIndex] = await Promise.all([
+        rIndexPromise,
+        cIndexPromise
+    ]);
+    // get the index that is the last used nexa addr
+    let indexes = {
+        rIndex: rIndex,
+        cIndex: cIndex
+    };
+    return indexes;
+}
+async function $f10b40ff0fa7ccfb$export$f421913908d4303e(masterKey) {
+    let accounts = [];
+    let index = 0;
+    while(true){
+        const nexaAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, index);
+        const indexes = await $f10b40ff0fa7ccfb$export$4aeb2c92e53ab137(nexaAccountKey);
+        if (indexes.rIndex < 0 && indexes.cIndex < 0) break;
+        if (indexes.rIndex < 0) indexes.rIndex = 0;
+        if (indexes.cIndex < 0) indexes.cIndex = 0;
+        // make account after break check, otherwise we might push an empty account
+        const nexaAccount = new (0, $3213756e8a8eb72f$export$2e2bcd8739ae039)(index, indexes, $f10b40ff0fa7ccfb$export$d6e8eb22902c6b88(nexaAccountKey, indexes.rIndex + 1, indexes.rIndex + 20, indexes.cIndex + 1, indexes.cIndex + 20));
+        await nexaAccount.loadBalances();
+        accounts.push(nexaAccount);
+        if (index == 0) index = 100;
+        else index++;
+    }
+    if (accounts.length == 0) {
+        // default account was unused but we need to populate at least one account,
+        // make the default account here
+        let defaultNexaAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, 0);
+        // get the last used indexes, -1 means unused
+        let defaultIndexes = {
+            rIndex: 0,
+            cIndex: 0
+        };
+        const defaultAccount = new (0, $3213756e8a8eb72f$export$2e2bcd8739ae039)(0, defaultIndexes, $f10b40ff0fa7ccfb$export$d6e8eb22902c6b88(defaultNexaAccountKey, defaultIndexes.rIndex, defaultIndexes.rIndex + 20, defaultIndexes.cIndex, defaultIndexes.cIndex + 20));
+        await defaultAccount.loadBalances();
+        accounts.push(defaultAccount);
+    }
+    return accounts;
+}
+async function $f10b40ff0fa7ccfb$var$findUsedVaultAccounts(masterKey) {
+    // all vaults are in bip44 account 1
+    let vaultAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, 1);
+    // all vaults are in the external chain
+    let vaultChain = vaultAccountKey.deriveChild(0, false);
+    // get the index that is the last used vault
+    return await $f10b40ff0fa7ccfb$var$discoverUsedAccountIndexes(vaultChain);
+}
+async function $f10b40ff0fa7ccfb$export$eb24265dd203eccb(masterKey) {
+    let accounts = [];
+    // all vaults are in bip44 account 1
+    let vaultAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, 1);
+    // find the next unused vault
+    let lastUsedVaultIndex = await $f10b40ff0fa7ccfb$var$findUsedVaultAccounts(masterKey);
+    // if all vaults unused, generate at least the first vault account
+    if (lastUsedVaultIndex < 0) lastUsedVaultIndex = 0;
+    // for each vault found, make the DefaultAccount for that vault
+    for(let index = 0; index <= lastUsedVaultIndex; index++){
+        const vaultAccount = new (0, $fcf0a0849682f4b5$export$2e2bcd8739ae039)(1, index, $f10b40ff0fa7ccfb$export$1e0ce394ebe84ca9(vaultAccountKey, index));
+        await vaultAccount.loadBalances();
+        accounts.push(vaultAccount);
+    }
+    return accounts;
+}
+async function $f10b40ff0fa7ccfb$var$findUsedDappAccounts(masterKey) {
+    // all dApp accounts are in bip44 account 2
+    let dappAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, 2);
+    // all dApp accounts use the external chain
+    let dappChain = dappAccountKey.deriveChild(0, false);
+    // get the index that is the next unused dApp account
+    return await $f10b40ff0fa7ccfb$var$discoverUsedAccountIndexes(dappChain);
+}
+async function $f10b40ff0fa7ccfb$export$e3d879d0e09f52c3(masterKey) {
+    let accounts = [];
+    // all dApp accounts are in bip44 account 2
+    let dappAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, 2);
+    // find the next unused dapp account
+    let lastUsedDappIndex = await $f10b40ff0fa7ccfb$var$findUsedDappAccounts(masterKey);
+    // if all dapp accounts unused, generate at least the first dapp account
+    if (lastUsedDappIndex < 0) lastUsedDappIndex = 0;
+    // for each dApp account found, make the DefaultAccount for that dApp account
+    // for each vault found, make the DefaultAccount for that vault
+    for(let index = 0; index <= lastUsedDappIndex; index++){
+        const dappAccount = new (0, $5ef3d149a7ae4b51$export$2e2bcd8739ae039)(2, index, $f10b40ff0fa7ccfb$export$1e0ce394ebe84ca9(dappAccountKey, index));
+        await dappAccount.loadBalances();
+        accounts.push(dappAccount);
+    }
+    return accounts;
+}
+async function $f10b40ff0fa7ccfb$export$4e4f91181d6bd31c(masterKey) {
+    let accounts = [];
+    // accounts 0, 100+
+    const nexaAccounts = await $f10b40ff0fa7ccfb$export$f421913908d4303e(masterKey);
+    // vaults in bip44 account 1
+    const vaultAccounts = await $f10b40ff0fa7ccfb$export$eb24265dd203eccb(masterKey);
+    // dApp accounts in bip44 account 2
+    const dappAccounts = await $f10b40ff0fa7ccfb$export$e3d879d0e09f52c3(masterKey);
+    // 3 - 99 are reserved and will go here when added
+    accounts = accounts.concat(nexaAccounts);
+    accounts = accounts.concat(vaultAccounts);
+    accounts = accounts.concat(dappAccounts);
+    return accounts;
+}
+async function $f10b40ff0fa7ccfb$var$isAddressUsed(address) {
+    try {
+        let firstUse = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getFirstUse(address);
+        return firstUse.tx_hash && firstUse.tx_hash !== "";
+    } catch (e) {
+        if (e instanceof Error && e.message.includes("not found")) return false;
+        throw e;
+    }
+}
+async function $f10b40ff0fa7ccfb$var$getKeyTokenBalance(key) {
+    let tokensBalance = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTokensBalance(key.address);
+    let balance = {};
+    for(const cToken in tokensBalance.confirmed)if (tokensBalance.confirmed[cToken] != 0) balance[cToken] = {
+        confirmed: BigInt(tokensBalance.confirmed[cToken]).toString(),
+        unconfirmed: "0"
+    };
+    for(const uToken in tokensBalance.unconfirmed)if (tokensBalance.unconfirmed[uToken] != 0) {
+        if (balance[uToken]) balance[uToken].unconfirmed = BigInt(tokensBalance.unconfirmed[uToken]).toString();
+        else balance[uToken] = {
+            confirmed: "0",
+            unconfirmed: BigInt(tokensBalance.unconfirmed[uToken]).toString()
+        };
+    }
+    return balance;
+}
+async function $f10b40ff0fa7ccfb$var$getAndUpdateAddressKeyBalance(key) {
+    let balance = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getBalance(key.address);
+    key.balance = (BigInt(balance.confirmed) + BigInt(balance.unconfirmed)).toString();
+    key.tokensBalance = await $f10b40ff0fa7ccfb$var$getKeyTokenBalance(key);
+    return balance;
+}
+async function $f10b40ff0fa7ccfb$export$9e38d26dbd7c33f4(keys) {
+    let promises = [];
+    keys.forEach((key)=>{
+        let b = $f10b40ff0fa7ccfb$var$getAndUpdateAddressKeyBalance(key);
+        promises.push(b);
+    });
+    return await Promise.all(promises);
+}
+function $f10b40ff0fa7ccfb$export$a26005fb5b8d1e4a(balances) {
+    let confirmed = new (0, $633cp$jsbigdecimal)(0), unconfirmed = new (0, $633cp$jsbigdecimal)(0);
+    balances.forEach((b)=>{
+        confirmed = confirmed.add(new (0, $633cp$jsbigdecimal)(b.confirmed));
+        unconfirmed = unconfirmed.add(new (0, $633cp$jsbigdecimal)(b.unconfirmed));
+    });
+    return {
+        confirmed: confirmed.getValue(),
+        unconfirmed: unconfirmed.getValue()
+    };
+}
+function $f10b40ff0fa7ccfb$export$dec515296f176dbe(balances) {
+    let tokensBalance = {};
+    balances.forEach((b)=>{
+        for(const key in b)if (tokensBalance[key]) {
+            tokensBalance[key].confirmed = (BigInt(tokensBalance[key].confirmed) + BigInt(b[key].confirmed)).toString();
+            tokensBalance[key].unconfirmed = (BigInt(tokensBalance[key].unconfirmed) + BigInt(b[key].unconfirmed)).toString();
+        } else tokensBalance[key] = {
+            confirmed: b[key].confirmed,
+            unconfirmed: b[key].unconfirmed
+        };
+    });
+    return tokensBalance;
+}
+async function $f10b40ff0fa7ccfb$export$a2ed4b531376a5a4(addresses, fromHeight) {
+    let index = 0, i = 0, data = new Map(), maxHeight = fromHeight;
+    for (let address of addresses){
+        i++;
+        let txHistory = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTransactionsHistory(address);
+        if (txHistory && txHistory.length > 0) {
+            index = i;
+            for (let tx of txHistory)if (tx.height === 0 || tx.height > fromHeight) {
+                maxHeight = Math.max(maxHeight, tx.height);
+                data.set(tx.tx_hash, tx);
+            }
+        }
+    }
+    return {
+        index: index,
+        txs: data,
+        lastHeight: maxHeight
+    };
+}
+async function $f10b40ff0fa7ccfb$var$rescanAddressesHistory(addresses) {
+    let index = 0, i = 0, minHeight = Number.MAX_SAFE_INTEGER;
+    for (let address of addresses){
+        i++;
+        let txHistory = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTransactionsHistory(address);
+        if (!(0, $633cp$isNil)(txHistory)) {
+            index = i;
+            let heights = txHistory.filter((tx)=>tx.height > 0).map((h)=>h.height);
+            if (!(0, $633cp$isNil)(heights)) minHeight = Math.min(minHeight, ...heights);
+        }
+    }
+    return {
+        index: index > 0 ? index + 1 : 0,
+        height: minHeight == Number.MAX_SAFE_INTEGER ? 0 : minHeight
+    };
+}
+async function $f10b40ff0fa7ccfb$export$ef13479e8d3251d7(accountType, masterKey) {
+    if (accountType == 0) {
+        let defaultNexaAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, 0);
+        const defaultIndexes = await $f10b40ff0fa7ccfb$export$4aeb2c92e53ab137(defaultNexaAccountKey);
+        if (defaultIndexes.rIndex < 0 && defaultIndexes.cIndex < 0) return 0;
+        else // account 0 was not empty
+        for(let index = 100;; index++){
+            const nexaAccountKey = $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9(masterKey, index);
+            const indexes = await $f10b40ff0fa7ccfb$export$4aeb2c92e53ab137(nexaAccountKey);
+            if (indexes.rIndex < 0 && indexes.cIndex < 0) return index;
+        }
+    } else if (accountType == 1) {
+        // find the next unused vault
+        const lastUsedVault = await $f10b40ff0fa7ccfb$var$findUsedVaultAccounts(masterKey);
+        return lastUsedVault + 1;
+    } else if (accountType == 2) {
+        // find the next unused dapp account
+        const lastUsedDappAccount = await $f10b40ff0fa7ccfb$var$findUsedDappAccounts(masterKey);
+        return lastUsedDappAccount + 1;
+    } else throw new Error("Can not get next account index. Invalid accountType.");
+}
+async function $f10b40ff0fa7ccfb$export$9c6f4f51acbc89b9(txHistory, myAddresses) {
+    let t = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTransaction(txHistory.tx_hash);
+    let outputs = t.vout.filter((utxo)=>!(0, $633cp$isNil)(utxo.scriptPubKey.addresses));
+    let isOutgoing = t.vin.length > 0 && myAddresses.includes(t.vin[0].addresses[0]);
+    let isIncoming = !isOutgoing || outputs.every((utxo)=>myAddresses.includes(utxo.scriptPubKey.addresses[0]));
+    let isConfirmed = t.height > 0;
+    let txEntry = {};
+    txEntry.txId = t.txid;
+    txEntry.txIdem = t.txidem;
+    txEntry.height = isConfirmed ? t.height : 0;
+    txEntry.time = isConfirmed ? t.time : (0, $424cf91992355440$export$78d0476e8d098ba7)();
+    txEntry.fee = t.fee_satoshi;
+    if (isOutgoing && isIncoming) {
+        txEntry.state = 'both';
+        txEntry.value = "0";
+        txEntry.payTo = "Payment to yourself";
+    } else if (isIncoming) {
+        txEntry.state = 'incoming';
+        let utxos = outputs.filter((utxo)=>myAddresses.includes(utxo.scriptPubKey.addresses[0]));
+        let amount = new (0, $633cp$jsbigdecimal)(0);
+        utxos.forEach((utxo)=>{
+            amount = amount.add(new (0, $633cp$jsbigdecimal)(utxo.value_satoshi));
+        });
+        txEntry.value = amount.getValue();
+        txEntry.payTo = utxos[0].scriptPubKey.addresses[0];
+    } else if (isOutgoing) {
+        txEntry.state = 'outgoing';
+        let utxos = outputs.filter((utxo)=>!myAddresses.includes(utxo.scriptPubKey.addresses[0]));
+        let amount = new (0, $633cp$jsbigdecimal)(0);
+        utxos.forEach((utxo)=>{
+            amount = amount.add(new (0, $633cp$jsbigdecimal)(utxo.value_satoshi));
+        });
+        txEntry.value = amount.getValue();
+        txEntry.payTo = utxos[0].scriptPubKey.addresses[0];
+    }
+    let [txType, txGroup, tokenAmount, extraGroup] = $f10b40ff0fa7ccfb$var$classifyTokenTransaction(t.vin, outputs, txEntry.state, myAddresses);
+    txEntry.txGroupType = txType;
+    txEntry.token = txGroup;
+    txEntry.tokenAmount = tokenAmount;
+    txEntry.extraGroup = extraGroup;
+    return txEntry;
+}
+function $f10b40ff0fa7ccfb$var$classifyTokenTransaction(vin, vout, txState, myAddresses) {
+    let groupInputs = vin.filter((input)=>!(0, $424cf91992355440$export$c8733ae29fb53302)(input.group));
+    let groupOutputs = vout.filter((output)=>!(0, $424cf91992355440$export$c8733ae29fb53302)(output.scriptPubKey.group));
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(groupInputs) && (0, $424cf91992355440$export$c8733ae29fb53302)(groupOutputs)) return [
+        0,
+        "none",
+        "0",
+        "none"
+    ];
+    let myGroupInputs = groupInputs.filter((input)=>myAddresses.includes(input.addresses[0]));
+    let myGroupOutputs = groupOutputs.filter((output)=>myAddresses.includes(output.scriptPubKey.addresses[0]));
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(myGroupInputs) && (0, $424cf91992355440$export$c8733ae29fb53302)(myGroupOutputs)) return [
+        0,
+        "none",
+        "0",
+        "none"
+    ];
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(groupInputs)) {
+        let group = myGroupOutputs.find((output)=>BigInt(output.scriptPubKey.groupQuantity) < 0n)?.scriptPubKey.group ?? "none";
+        return [
+            1,
+            group,
+            "0",
+            "none"
+        ];
+    }
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(groupOutputs)) {
+        if (txState === 'incoming') return [
+            0,
+            "none",
+            "0",
+            "none"
+        ];
+        let inputs = myGroupInputs.filter((input)=>BigInt(input.groupQuantity) > 0n);
+        if (!(0, $424cf91992355440$export$c8733ae29fb53302)(inputs)) {
+            let amount = new (0, $633cp$jsbigdecimal)(0);
+            inputs.forEach((utxo)=>{
+                amount = amount.add(new (0, $633cp$jsbigdecimal)(utxo.groupQuantity));
+            });
+            let group = inputs[0].group;
+            let extraGroup = myGroupInputs.find((input)=>BigInt(input.groupQuantity) < 0n && inputs[0].group != input.group)?.group ?? "none";
+            return [
+                3,
+                group,
+                amount.getValue(),
+                extraGroup
+            ];
+        }
+        let group = myGroupInputs.find((input)=>BigInt(input.groupQuantity) < 0n)?.group ?? "none";
+        let extraGroup = myGroupInputs.find((input)=>BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [
+            3,
+            group,
+            "0",
+            extraGroup
+        ];
+    }
+    let tokenInputs = groupInputs.filter((input)=>BigInt(input.groupQuantity) > 0n);
+    let tokenOutputs = groupOutputs.filter((output)=>BigInt(output.scriptPubKey.groupQuantity) > 0n);
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(tokenInputs) && (0, $424cf91992355440$export$c8733ae29fb53302)(tokenOutputs)) {
+        let group = groupInputs.find((input)=>BigInt(input.groupQuantity) < 0n)?.group ?? "none";
+        let extraGroup = groupOutputs.find((output)=>BigInt(output.scriptPubKey.groupQuantity) < 0n && group != output.scriptPubKey.group)?.scriptPubKey.group ?? "none";
+        return [
+            4,
+            extraGroup !== 'none' ? extraGroup : group,
+            "0",
+            extraGroup !== 'none' ? group : extraGroup
+        ];
+    }
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(tokenInputs)) {
+        let group = tokenOutputs[0].scriptPubKey.group;
+        let amount = new (0, $633cp$jsbigdecimal)(0);
+        tokenOutputs.forEach((utxo)=>{
+            amount = amount.add(new (0, $633cp$jsbigdecimal)(utxo.scriptPubKey.groupQuantity));
+        });
+        let extraGroup = groupInputs.find((input)=>BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [
+            2,
+            group,
+            amount.getValue(),
+            extraGroup
+        ];
+    }
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(tokenOutputs)) {
+        let group = tokenInputs[0].group;
+        let amount = new (0, $633cp$jsbigdecimal)(0);
+        tokenInputs.forEach((utxo)=>{
+            amount = amount.add(new (0, $633cp$jsbigdecimal)(utxo.groupQuantity));
+        });
+        let extraGroup = groupInputs.find((input)=>BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [
+            3,
+            group,
+            amount.getValue(),
+            extraGroup
+        ];
+    }
+    let outQuantitySum = tokenOutputs.map((output)=>BigInt(output.scriptPubKey.groupQuantity)).reduce((a, b)=>a + b, 0n);
+    let inQuantitySum = tokenInputs.map((input)=>BigInt(input.groupQuantity)).reduce((a, b)=>a + b, 0n);
+    if (outQuantitySum > inQuantitySum) {
+        let group = tokenOutputs[0].scriptPubKey.group;
+        let extraGroup = groupInputs.find((input)=>BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [
+            2,
+            group,
+            (outQuantitySum - inQuantitySum).toString(),
+            extraGroup
+        ];
+    }
+    if (inQuantitySum > outQuantitySum) {
+        let group = tokenInputs[0].group;
+        let extraGroup = groupInputs.find((input)=>BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [
+            3,
+            group,
+            (inQuantitySum - outQuantitySum).toString(),
+            extraGroup
+        ];
+    }
+    let group = tokenOutputs[0].scriptPubKey.group;
+    let amount = "";
+    if (txState === 'incoming') amount = tokenOutputs.filter((output)=>myAddresses.includes(output.scriptPubKey.addresses[0])).map((output)=>BigInt(output.scriptPubKey.groupQuantity)).reduce((a, b)=>a + b, 0n).toString();
+    else if (txState === 'outgoing') amount = tokenOutputs.filter((output)=>!myAddresses.includes(output.scriptPubKey.addresses[0])).map((output)=>BigInt(output.scriptPubKey.groupQuantity)).reduce((a, b)=>a + b, 0n).toString();
+    else amount = "0";
+    return [
+        5,
+        group,
+        amount,
+        "none"
+    ];
+}
+
+
+
+
+
+
+
+
+
+function $3091f185ded8655f$export$7f7cffd29bf2d96d(authFlags, permission) {
+    if (authFlags > 0) return false;
+    let flags = BigInt.asUintN(64, BigInt(authFlags));
+    switch(permission){
+        case 'authorise':
+            return (0, $633cp$GroupToken).allowsRenew(flags);
+        case 'mint':
+            return (0, $633cp$GroupToken).allowsMint(flags);
+        case 'melt':
+            return (0, $633cp$GroupToken).allowsMelt(flags);
+        case 'rescript':
+            return (0, $633cp$GroupToken).allowsRescript(flags);
+        case 'subgroup':
+            return (0, $633cp$GroupToken).allowsSubgroup(flags);
+        default:
+            return false;
+    }
+}
+function $3091f185ded8655f$export$636fb0b03b94ac81(authFlags, withSubgroup = true) {
+    if (authFlags > 0) return 0n;
+    let flags = BigInt.asUintN(64, BigInt(authFlags));
+    let newFlags = (0, $633cp$GroupToken).authFlags.AUTHORITY;
+    if ((0, $633cp$GroupToken).allowsRenew(flags)) newFlags |= (0, $633cp$GroupToken).authFlags.BATON;
+    if ((0, $633cp$GroupToken).allowsMint(flags)) newFlags |= (0, $633cp$GroupToken).authFlags.MINT;
+    if ((0, $633cp$GroupToken).allowsMelt(flags)) newFlags |= (0, $633cp$GroupToken).authFlags.MELT;
+    if ((0, $633cp$GroupToken).allowsRescript(flags)) newFlags |= (0, $633cp$GroupToken).authFlags.RESCRIPT;
+    if ((0, $633cp$GroupToken).allowsSubgroup(flags) && withSubgroup) newFlags |= (0, $633cp$GroupToken).authFlags.SUBGROUP;
+    return newFlags;
+}
+function $3091f185ded8655f$export$e240c810a53c3a0c(perms) {
+    let newFlags = (0, $633cp$GroupToken).authFlags.AUTHORITY;
+    for (let perm of perms)switch(perm){
+        case 'authorise':
+            newFlags |= (0, $633cp$GroupToken).authFlags.BATON;
+            break;
+        case 'mint':
+            newFlags |= (0, $633cp$GroupToken).authFlags.MINT;
+            break;
+        case 'melt':
+            newFlags |= (0, $633cp$GroupToken).authFlags.MELT;
+            break;
+        case 'rescript':
+            newFlags |= (0, $633cp$GroupToken).authFlags.RESCRIPT;
+            break;
+        case 'subgroup':
+            newFlags |= (0, $633cp$GroupToken).authFlags.SUBGROUP;
+            break;
+    }
+    return newFlags;
+}
+
+
+/** Maximum number of inputs/outputs allowed in a single transaction */ const $42a254343af658f0$var$MAX_INPUTS_OUTPUTS = 250;
+async function $42a254343af658f0$export$afd979971a55acfc(txBuilder, keys, totalTxValue, options) {
+    let rKeys = keys.receiveKeys.filter((k)=>BigInt(k.balance) > 0n);
+    let cKeys = keys.changeKeys.filter((k)=>BigInt(k.balance) > 0n);
+    let allKeys = rKeys.concat(cKeys);
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(allKeys)) throw new Error("Not enough Nexa balance.");
+    let usedKeys = new Map();
+    let origAmount = options.isConsolidate ? 0 : Number(totalTxValue);
+    for (let key of allKeys){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getNexaUtxos(key.address);
+        for (let utxo of utxos){
+            let input = {
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value,
+                templateData: options.templateData
+            };
+            txBuilder.from(input);
+            if (!usedKeys.has(key.address)) usedKeys.set(key.address, key.key.privateKey);
+            if (options.isConsolidate) {
+                txBuilder.change(options.toChange ?? keys.receiveKeys[keys.receiveKeys.length - 1].address);
+                if (txBuilder.transaction.inputs.length > $42a254343af658f0$var$MAX_INPUTS_OUTPUTS) return Array.from(usedKeys.values());
+            } else {
+                let tx = txBuilder.transaction;
+                if (tx.inputs.length > $42a254343af658f0$var$MAX_INPUTS_OUTPUTS) throw new Error("Too many inputs. Consider consolidate transactions or reduce the send amount.");
+                let unspent = tx.getUnspentValue();
+                if (unspent < 0n) continue;
+                if (unspent == 0n && options.feeFromAmount) {
+                    let txFee = tx.estimateRequiredFee();
+                    tx.updateOutputAmount(0, origAmount - txFee);
+                    return Array.from(usedKeys.values());
+                }
+                txBuilder.change(options.toChange ?? keys.changeKeys[keys.changeKeys.length - 1].address);
+                if (options.feeFromAmount) {
+                    let hasChange = tx.getChangeOutput();
+                    let txFee = tx.estimateRequiredFee();
+                    tx.updateOutputAmount(0, origAmount - txFee);
+                    // edge case where change added after update
+                    if (!hasChange && tx.getChangeOutput()) {
+                        txFee = tx.estimateRequiredFee();
+                        tx.updateOutputAmount(0, origAmount - txFee);
+                    }
+                }
+                // check again after change output manipulation
+                if (tx.getUnspentValue() < tx.estimateRequiredFee()) continue;
+                return Array.from(usedKeys.values());
+            }
+        }
+    }
+    if (options.isConsolidate) {
+        if (usedKeys.size > 0) return Array.from(usedKeys.values());
+        throw new Error("Not enough Nexa balance.");
+    }
+    let err = {
+        errorMsg: "Not enough Nexa balance.",
+        amount: (0, $633cp$UnitUtils).formatNEXA(txBuilder.transaction.outputs[0].value),
+        fee: (0, $633cp$UnitUtils).formatNEXA(txBuilder.transaction.estimateRequiredFee())
+    };
+    throw new Error(JSON.stringify(err));
+}
+async function $42a254343af658f0$export$931e37acdaa22dcf(txBuilder, keys, token, outTokenAmount) {
+    let tokenHex = (0, $424cf91992355440$export$254a5c7330bbfd41)(token);
+    let rKeys = keys.receiveKeys.filter((k)=>Object.keys(k.tokensBalance).includes(tokenHex));
+    let cKeys = keys.changeKeys.filter((k)=>Object.keys(k.tokensBalance).includes(tokenHex));
+    let allKeys = rKeys.concat(cKeys);
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(allKeys)) throw new Error("Not enough token balance.");
+    let usedKeys = new Map();
+    let inTokenAmount = 0n;
+    for (let key of allKeys){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTokenUtxos(key.address, token);
+        for (let utxo of utxos){
+            if (utxo.token_amount < 0) continue;
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value,
+                groupId: utxo.group,
+                groupAmount: BigInt(utxo.token_amount)
+            });
+            inTokenAmount = inTokenAmount + BigInt(utxo.token_amount);
+            if (!usedKeys.has(key.address)) usedKeys.set(key.address, key.key.privateKey);
+            if (inTokenAmount > (0, $424cf91992355440$export$8ba128bc85947a2a)) throw new Error("Token inputs exceeded max amount. Consider sending in small chunks");
+            if (txBuilder.transaction.inputs.length > $42a254343af658f0$var$MAX_INPUTS_OUTPUTS) throw new Error("Too many inputs. Consider consolidating transactions or reduce the send amount.");
+            if (inTokenAmount == outTokenAmount) return Array.from(usedKeys.values());
+            if (inTokenAmount > outTokenAmount) {
+                // change
+                txBuilder.to(keys.changeKeys[keys.changeKeys.length - 1].address, (0, $633cp$Transaction).DUST_AMOUNT, token, inTokenAmount - outTokenAmount);
+                return Array.from(usedKeys.values());
+            }
+        }
+    }
+    throw new Error("Not enough token balance");
+}
+async function $42a254343af658f0$export$d7f2b844e1d59768(txBuilder, keys, opReturnData, network) {
+    // TODO validate opreturn data
+    const allKeys = keys.receiveKeys.concat(keys.changeKeys);
+    let outpoint = '';
+    let usedKeys = [];
+    let signKey = undefined;
+    for (let key of allKeys){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getNexaUtxos(key.address);
+        for (let utxo of utxos){
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value
+            });
+            if ((0, $424cf91992355440$export$c8733ae29fb53302)(outpoint)) {
+                outpoint = utxo.outpoint_hash;
+                let id = (0, $633cp$GroupToken).findGroupId(Buffer.from(outpoint, 'hex'), Buffer.from(opReturnData, 'hex'), (0, $633cp$GroupToken).authFlags.ACTIVE_FLAG_BITS);
+                const groupId = new (0, $633cp$Address)(id.hashBuffer, network, (0, $633cp$AddressType).GroupIdAddress).toString();
+                txBuilder.to(keys.receiveKeys.at(-1).address, (0, $633cp$Transaction).DUST_AMOUNT, groupId, (0, $633cp$GroupToken).authFlags.ACTIVE_FLAG_BITS | id.nonce);
+                signKey = key.key.privateKey;
+                usedKeys.push(signKey);
+                return usedKeys;
+            }
+        }
+    }
+    throw new Error("Not enough Nexa balance.");
+}
+async function $42a254343af658f0$export$48a48877d6df17e9(txBuilder, keys, outpoint) {
+    let utxo = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getUtxo(outpoint);
+    let address = utxo.addresses[0];
+    txBuilder.from({
+        outpoint: outpoint,
+        address: address,
+        satoshis: utxo.amount
+    });
+    let allKeys = keys.receiveKeys.concat(keys.changeKeys);
+    let addrKey = allKeys.find((k)=>k.address === address);
+    if (!addrKey) throw new Error('UTXO associated key not found in the wallet');
+    return [
+        addrKey.key.privateKey
+    ];
+}
+async function $42a254343af658f0$export$1dfa5d829fc95097(txBuilder, keys, token, perm, subgroup = '', subgroupAddr = '') {
+    let allKeys = keys.receiveKeys.concat(keys.changeKeys);
+    for (let key of allKeys){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTokenUtxos(key.address, token);
+        for (let utxo of utxos){
+            if (!(0, $3091f185ded8655f$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) continue;
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value
+            });
+            if (perm === 'subgroup') txBuilder.to(subgroupAddr, (0, $633cp$Transaction).DUST_AMOUNT, subgroup, (0, $3091f185ded8655f$export$636fb0b03b94ac81)(utxo.token_amount, false));
+            // if renew flag included, we don't want to burn it
+            if ((0, $633cp$GroupToken).allowsRenew(BigInt.asUintN(64, BigInt(utxo.token_amount)))) txBuilder.to(keys.receiveKeys.at(-1).address, (0, $633cp$Transaction).DUST_AMOUNT, token, (0, $3091f185ded8655f$export$636fb0b03b94ac81)(utxo.token_amount));
+            return [
+                key.key.privateKey
+            ];
+        }
+    }
+    throw new Error("The requested authority not found");
+}
+async function $42a254343af658f0$export$28a843ca046a6b3f(txBuilder, keys, token, perms, toAddr) {
+    let allKeys = keys.receiveKeys.concat(keys.changeKeys);
+    let usedKeys = [];
+    let reqiredPerms = new Set(perms);
+    reqiredPerms.add('authorise');
+    for (let key of allKeys){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTokenUtxos(key.address, token);
+        for (let utxo of utxos){
+            if (utxo.token_amount > 0) continue;
+            let found = false;
+            for (let perm of reqiredPerms)if ((0, $3091f185ded8655f$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) {
+                reqiredPerms.delete(perm);
+                found = true;
+            }
+            if (!found) continue;
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value
+            });
+            usedKeys.push(key.key.privateKey);
+            // duplicate
+            txBuilder.to(toAddr != null ? toAddr : keys.receiveKeys.at(-1).address, (0, $633cp$Transaction).DUST_AMOUNT, token, (0, $3091f185ded8655f$export$636fb0b03b94ac81)(utxo.token_amount));
+            if (reqiredPerms.size === 0) return usedKeys;
+        }
+    }
+    throw new Error("The required authorities not found");
+}
+
+
+
+
+
+
+class $def4af748ddce85f$export$bba690fb5c12ba04 {
+    /**
+     * Creates a new TransactionCreator instance
+     * @param tx Optional existing TransactionBuilder, hex string, or buffer
+     */ constructor(tx){
+        /** Array of async functions to execute when building the transaction */ this._builder = [];
+        /** Total value of NEXA being sent in this transaction */ this._totalValue = BigInt(0);
+        /** Network this transaction will be broadcast on */ this._network = (0, $633cp$Networks).mainnet;
+        /** Transaction options for customizing behavior */ this._txOptions = {};
+        if (tx instanceof (0, $633cp$TransactionBuilder)) this.transactionBuilder = tx;
+        this.tokens = new Set();
+        this.transactionBuilder = new (0, $633cp$TransactionBuilder)();
+    }
+    /**
+     * Sets the network for this transaction
+     * @param network Network name or Networkish object
+     * @returns This instance for chaining
+     */ onNetwork(network) {
+        this.network = (0, $633cp$Networks).get(network);
+        return this;
+    }
+    /** Gets transaction options */ get txOptions() {
+        return this._txOptions;
+    }
+    /** Sets transaction options */ set txOptions(value) {
+        this._txOptions = value;
+    }
+    /** Gets the network for this transaction */ get network() {
+        return this._network;
+    }
+    /** Sets the network for this transaction */ set network(value) {
+        this._network = value;
+    }
+    /** Gets the builder function array */ get builder() {
+        return this._builder;
+    }
+    /** Sets the builder function array */ set builder(value) {
+        this._builder = value;
+    }
+    /** Gets the underlying transaction builder */ get transactionBuilder() {
+        return this._transactionBuilder;
+    }
+    /** Sets the underlying transaction builder */ set transactionBuilder(value) {
+        this._transactionBuilder = value;
+    }
+    /** Gets the set of token actions */ get tokens() {
+        return this._tokens;
+    }
+    /** Sets the set of token actions */ set tokens(value) {
+        this._tokens = value;
+    }
+    /** Gets the total NEXA value being sent */ get totalValue() {
+        return this._totalValue;
+    }
+    /** Sets the total NEXA value being sent */ set totalValue(value) {
+        this._totalValue = value;
+    }
+    /**
+     * Validates and creates a token action
+     * @param toAddr Destination address
+     * @param amount Amount to send
+     * @param token Token ID
+     * @param action Action type (mint, melt, send, etc.)
+     * @throws Error if validation fails
+     */ tokenAction(toAddr, amount, token, action) {
+        // Validate destination address
+        if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network) && !(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network, (0, $633cp$AddressType).PayToPublicKeyHash)) throw new Error('Invalid Address.');
+        // Validate amount ranges
+        if (token && BigInt(amount) < 1n || !token && (0, $633cp$parseInt)(amount) < (0, $633cp$Transaction).DUST_AMOUNT) throw new Error("The amount is too low.");
+        if (token && BigInt(amount) > (0, $424cf91992355440$export$8ba128bc85947a2a) || !token && (0, $633cp$parseInt)(amount) > (0, $633cp$Transaction).MAX_MONEY) throw new Error("The amount is too high.");
+        // Validate token ID
+        if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(token, this.network, (0, $633cp$AddressType).GroupIdAddress)) throw new Error('Invalid Token ID');
+        // Ensure tokens are sent to script template addresses
+        if ((0, $633cp$Address).getOutputType(toAddr) === 0) throw new Error('Token must be sent to script template address');
+        // Add output to transaction
+        this.transactionBuilder.to(toAddr, (0, $633cp$Transaction).DUST_AMOUNT, token, BigInt(amount));
+        // Record the token action
+        this.tokens.add({
+            token: token,
+            amount: BigInt(amount),
+            action: action
+        });
+    }
+    /**
+     * Configures transaction to consolidate UTXOs to a single address
+     * @param toAddr Address to consolidate funds to
+     * @returns This instance for chaining
+     */ consolidate(toAddr) {
+        this.builder.push(async ()=>{
+            if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network) && !(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network, (0, $633cp$AddressType).PayToPublicKeyHash)) throw new Error('Invalid Address.');
+            this._txOptions.isConsolidate = true;
+            this._txOptions.toChange = toAddr;
+        });
+        return this;
+    }
+    /**
+     * Configures transaction to deduct fee from the send amount
+     * @returns This instance for chaining
+     */ feeFromAmount() {
+        this.builder.push(async ()=>{
+            this._txOptions.feeFromAmount = true;
+        });
+        return this;
+    }
+    /**
+     * Adds a token send operation to the transaction
+     * @param toAddr Destination address
+     * @param amount Amount of tokens to send
+     * @param token Token ID
+     * @returns This instance for chaining
+     */ sendToToken(toAddr, amount, token) {
+        this.builder.push(async ()=>{
+            this.tokenAction(toAddr, amount, token, 'send');
+        });
+        return this;
+    }
+    /**
+     * Adds a NEXA send operation to the transaction
+     * @param toAddr Destination address
+     * @param amount Amount of NEXA to send
+     * @returns This instance for chaining
+     */ sendTo(toAddr, amount) {
+        this.builder.push(async ()=>{
+            if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network) && !(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network, (0, $633cp$AddressType).PayToPublicKeyHash)) throw new Error('Invalid Address.');
+            this.transactionBuilder.to(toAddr, amount);
+            this.totalValue = BigInt(this.totalValue + amount);
+        });
+        return this;
+    }
+    /**
+     * Adds a token authority renewal operation
+     * @param token Token ID to renew authority for
+     * @param perms Permissions to renew
+     * @param toAddr
+     * @returns This instance for chaining
+     */ renewAuthority(token, perms, toAddr) {
+        this.builder.push(async ()=>{
+            if (toAddr != null) {
+                if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network) && !(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(toAddr, this.network, (0, $633cp$AddressType).PayToPublicKeyHash)) throw new Error('Invalid Address.');
+            }
+            this.tokens.add({
+                token: token,
+                action: 'renew',
+                amount: BigInt((0, $633cp$Transaction).DUST_AMOUNT),
+                parentToken: undefined,
+                extraData: {
+                    perms: perms,
+                    address: toAddr
+                }
+            });
+        });
+        return this;
+    }
+    /**
+     * Adds a token authority deletion operation
+     * @param token Token ID to delete authority for
+     * @param outpoint Outpoint of the authority to delete
+     * @returns This instance for chaining
+     */ deleteAuthority(token, outpoint) {
+        this.builder.push(async ()=>{
+            this.tokens.add({
+                token: token,
+                action: 'delete',
+                amount: BigInt((0, $633cp$Transaction).DUST_AMOUNT),
+                parentToken: undefined,
+                extraData: {
+                    outpoint: outpoint
+                }
+            });
+        });
+        return this;
+    }
+    /**
+     * Creates a legacy token (not implemented)
+     * @returns This instance for chaining
+     */ legacyToken(name, ticker, decimals, docUrl, docHash) {
+        this.builder.push(async ()=>{
+            const opReturn = (0, $633cp$ScriptFactory).buildTokenDescriptionLegacy(ticker, name, docUrl, docHash, decimals);
+            this.transactionBuilder.addData(opReturn, true);
+            this.tokens.add({
+                action: 'group',
+                amount: BigInt((0, $633cp$Transaction).DUST_AMOUNT),
+                extraData: {
+                    opReturnData: opReturn.toHex()
+                }
+            });
+        });
+        return this;
+    }
+    /**
+     * Creates a legacy group (not implemented)
+     * @returns This instance for chaining
+     */ legacyGroup(name, ticker, docUrl, docHash) {
+        this.builder.push(async ()=>{
+            const opReturn = (0, $633cp$ScriptFactory).buildTokenDescriptionLegacy(ticker, name, docUrl, docHash);
+            this.transactionBuilder.addData(opReturn, true);
+            this.tokens.add({
+                action: 'group',
+                amount: BigInt((0, $633cp$Transaction).DUST_AMOUNT),
+                extraData: {
+                    opReturnData: opReturn.toHex()
+                }
+            });
+        });
+        return this;
+    }
+    /**
+     * Creates a token with metadata
+     * @param name Token name
+     * @param ticker Token ticker symbol
+     * @param decimals Number of decimal places
+     * @param docUrl URL to token documentation
+     * @param docHash Hash of token documentation
+     * @returns This instance for chaining
+     */ token(name, ticker, decimals, docUrl, docHash) {
+        this.builder.push(async ()=>{
+            const opReturn = (0, $633cp$ScriptFactory).buildTokenDescription(ticker, name, docUrl, docHash, decimals);
+            this.transactionBuilder.addData(opReturn, true);
+            this.tokens.add({
+                action: 'group',
+                amount: BigInt((0, $633cp$Transaction).DUST_AMOUNT),
+                extraData: {
+                    opReturnData: opReturn.toHex()
+                }
+            });
+        });
+        return this;
+    }
+    /**
+     * Creates an NFT collection with metadata
+     * @param name Collection name
+     * @param ticker Collection ticker symbol
+     * @param docUrl URL to collection documentation
+     * @param docHash Hash of collection documentation
+     * @returns This instance for chaining
+     */ collection(name, ticker, docUrl, docHash) {
+        this.builder.push(async ()=>{
+            const opReturn = (0, $633cp$ScriptFactory).buildNFTCollectionDescription(ticker, name, docUrl, docHash);
+            this.transactionBuilder.addData(opReturn, true);
+            this.tokens.add({
+                action: 'group',
+                amount: BigInt((0, $633cp$Transaction).DUST_AMOUNT),
+                extraData: {
+                    opReturnData: opReturn.toHex()
+                }
+            });
+        });
+        return this;
+    }
+    /**
+     * Creates an NFT within a collection
+     * @param parent Parent collection token ID
+     * @param zipUrl URL to NFT content ZIP file
+     * @param zipHash Hash of NFT content ZIP file
+     * @returns This instance for chaining
+     */ nft(parent, zipUrl, zipHash) {
+        this.builder.push(async ()=>{
+            // add op_return for the nft
+            let opReturn = (0, $633cp$ScriptFactory).buildNFTDescription(zipUrl, zipHash);
+            this.transactionBuilder.addData(opReturn, true);
+            // generate subgroup ID
+            const subGroup = (0, $633cp$GroupToken).generateSubgroupId(parent, opReturn.toBuffer()).toString('hex');
+            this.tokens.add({
+                token: subGroup,
+                parentToken: parent,
+                amount: BigInt((0, $633cp$Transaction).DUST_AMOUNT),
+                action: 'subgroup'
+            });
+        });
+        return this;
+    }
+    /**
+     * Adds an OP_RETURN output to the transaction
+     * @param data Data to include in the OP_RETURN
+     * @param isFullScript Whether the data is already a complete script
+     * @returns This instance for chaining
+     */ addOpReturn(data, isFullScript = false) {
+        this.builder.push(async ()=>{
+            let script = isFullScript ? new (0, $633cp$Script)(data) : (0, $633cp$ScriptFactory).buildDataOut(data);
+            let output = new (0, $633cp$Output)(0, script);
+            this.transactionBuilder.transaction.addOutput(output);
+        });
+        return this;
+    }
+    /**
+     * Builds the transaction by executing all queued operations
+     * @returns Promise resolving to the serialized transaction hex
+     */ async build() {
+        for (const task of this.builder)await task();
+        return this.transactionBuilder.transaction.serialize({
+            disableAll: true
+        });
+    }
+}
+
+
+class $d9127651ccaae19d$export$2e2bcd8739ae039 extends (0, $def4af748ddce85f$export$bba690fb5c12ba04) {
+    constructor(fromAccount, tx){
+        super(tx), this._keysToSign = [];
+        this._account = fromAccount;
+        this.validateAccount();
+    }
+    fromAccount(fromAccount) {
+        this._account = fromAccount;
+        return this;
+    }
+    parseTxHex(tx) {
+        this.builder.push(async ()=>{
+            const txBuilder = new (0, $633cp$TransactionBuilder)(tx);
+            const newTxBuilder = new (0, $633cp$TransactionBuilder)();
+            const oldInputs = txBuilder.transaction.inputs;
+            for (const input of oldInputs){
+                const utxo = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getUtxo(input.outpoint.toString('hex'));
+                newTxBuilder.from({
+                    outpoint: utxo.tx_hash,
+                    amount: utxo.amount,
+                    scriptPubKey: utxo.scriptpubkey
+                });
+                const foundKey = this.findPrivateKeyFromAddress(utxo.addresses[0]);
+                if (foundKey) this._keysToSign.push(foundKey.key.privateKey);
+            }
+            newTxBuilder.transaction.outputs = txBuilder.transaction.outputs;
+        });
+        return this;
+    }
+    parseTxBuffer(tx) {
+        this.builder.push(async ()=>{
+            this.transactionBuilder = new (0, $633cp$TransactionBuilder)(tx);
+        });
+        return this;
+    }
+    mint(token, amount) {
+        this.builder.push(async ()=>{
+            let toAddr = this._account.accountKeys.receiveKeys.at(-1).address;
+            this.tokenAction(toAddr, amount, token, 'mint');
+        });
+        return this;
+    }
+    melt(token, amount) {
+        this.builder.push(async ()=>{
+            let toAddr = this._account.accountKeys.receiveKeys.at(-1).address;
+            this.tokenAction(toAddr, amount, token, 'melt');
+        });
+        return this;
+    }
+    populate() {
+        this.validateAccount();
+        this.builder.push(async ()=>{
+            let tK = [];
+            let nK = [];
+            if (this.tokens.size > 0) for (const tokenAction of this.tokens){
+                if (tokenAction.action == 'mint' || tokenAction.action == 'melt') tK = tK.concat(await (0, $42a254343af658f0$export$1dfa5d829fc95097)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.action));
+                else if (tokenAction.action == 'group') tK = tK.concat(await (0, $42a254343af658f0$export$d7f2b844e1d59768)(this.transactionBuilder, this._account.accountKeys, tokenAction.extraData?.opReturnData, this.network));
+                else if (tokenAction.action == 'subgroup') tK = tK.concat(await (0, $42a254343af658f0$export$1dfa5d829fc95097)(this.transactionBuilder, this._account.accountKeys, tokenAction.parentToken, 'subgroup', tokenAction.token, this._account.accountKeys.receiveKeys.at(-1).address));
+                else if (tokenAction.action == 'renew') tK = tK.concat(await (0, $42a254343af658f0$export$28a843ca046a6b3f)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.extraData.perms, tokenAction.extraData.address));
+                else if (tokenAction.action == 'delete') tK = tK.concat(await (0, $42a254343af658f0$export$48a48877d6df17e9)(this.transactionBuilder, this._account.accountKeys, tokenAction.extraData.outpoint));
+                else tK = tK.concat(await (0, $42a254343af658f0$export$931e37acdaa22dcf)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.amount));
+                this._keysToSign.concat(tK);
+            }
+            nK = nK.concat(await (0, $42a254343af658f0$export$afd979971a55acfc)(this.transactionBuilder, this._account.accountKeys, this.totalValue, this.txOptions));
+            this._keysToSign = tK.concat(nK);
+        });
+        return this;
+    }
+    sign() {
+        this.builder.push(async ()=>{
+            const blockHeight = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getBlockTip();
+            this.transactionBuilder.lockUntilBlockHeight(blockHeight.height).sign(this._keysToSign);
+        });
+        return this;
+    }
+    /**
+     * Validates that the account has the necessary keys before performing operations
+     * @throws Error if account or keys are not properly initialized
+     */ validateAccount() {
+        if (!this._account) throw new Error('Account must be set before performing transactions');
+        if (!this._account.accountKeys) throw new Error('Account keys are not initialized');
+        if (!this._account.accountKeys.receiveKeys || this._account.accountKeys.receiveKeys.length === 0) throw new Error('No receive keys available in account');
+    }
+    findPrivateKeyFromAddress(addr) {
+        const keys = this._account.accountKeys.receiveKeys.concat(this._account.accountKeys.changeKeys);
+        return keys.find((key)=>key.address === addr);
+    }
+}
+
+
+
+
+
+
+class $f956f86dd8b9f336$export$2e2bcd8739ae039 {
+    /**
+     * Creates a new AccountStore instance
+     * Initializes an empty map to store accounts
+     */ constructor(){
+        this._accounts = new Map();
+    }
+    /**
+     * Generates a unique store key for an account based on its type and index
+     * @param accountType The type of account (DAPP, VAULT, or DEFAULT)
+     * @param index The account index
+     * @returns Unique string key for storing the account
+     */ getAccountStoreKey(accountType, index) {
+        switch(accountType){
+            case (0, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7).DAPP_ACCOUNT:
+                // DApp accounts use format: "2.index"
+                return String(accountType + '.' + index);
+            case (0, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7).VAULT_ACCOUNT:
+                // Vault accounts use format: "1.index"
+                return String(accountType + '.' + index);
+            default:
+                // Default accounts use just the index
+                return String(index);
+        }
+    }
+    /**
+     * Creates a new account of the specified type
+     * @param accountType Type of account to create (DAPP, VAULT, or DEFAULT)
+     * @param masterKey Master HD private key for deriving account keys
+     * @returns Promise resolving to the created account
+     */ async createAccount(accountType, masterKey) {
+        // Get the next available index for this account type
+        const nextIndex = await (0, $f10b40ff0fa7ccfb$export$ef13479e8d3251d7)(accountType, masterKey);
+        const accountStoreKey = this.getAccountStoreKey(accountType, nextIndex);
+        // Check if account already exists
+        const indexExists = this._accounts.get(String(accountStoreKey));
+        if (indexExists) return indexExists;
+        switch(accountType){
+            case (0, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7).DAPP_ACCOUNT:
+                // Create DApp account (purpose 2)
+                let dappAccountKey = (0, $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9)(masterKey, 2);
+                const dAppAccount = new (0, $5ef3d149a7ae4b51$export$2e2bcd8739ae039)(2, nextIndex, (0, $f10b40ff0fa7ccfb$export$1e0ce394ebe84ca9)(dappAccountKey, nextIndex));
+                await dAppAccount.loadBalances();
+                this._accounts.set(dAppAccount.getAccountStoreKey(), dAppAccount);
+                return dAppAccount;
+            case (0, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7).VAULT_ACCOUNT:
+                // Create Vault account (purpose 1)
+                let vaultAccountKey = (0, $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9)(masterKey, 1);
+                const vaultAccount = new (0, $fcf0a0849682f4b5$export$2e2bcd8739ae039)(1, nextIndex, (0, $f10b40ff0fa7ccfb$export$1e0ce394ebe84ca9)(vaultAccountKey, nextIndex));
+                await vaultAccount.loadBalances();
+                this._accounts.set(vaultAccount.getAccountStoreKey(), vaultAccount);
+                return vaultAccount;
+            default:
+                // Create default NEXA account with receive and change addresses
+                let nexaAccountKey = (0, $f10b40ff0fa7ccfb$export$b3a12d67e2f5f8c9)(masterKey, nextIndex);
+                const nexaAccountIndexes = {
+                    rIndex: 0,
+                    cIndex: 0
+                };
+                const nexaAccount = new (0, $3213756e8a8eb72f$export$2e2bcd8739ae039)(nextIndex, nexaAccountIndexes, (0, $f10b40ff0fa7ccfb$export$d6e8eb22902c6b88)(nexaAccountKey, nexaAccountIndexes.rIndex + 1, nexaAccountIndexes.rIndex + 20, nexaAccountIndexes.cIndex + 1, nexaAccountIndexes.cIndex + 20));
+                await nexaAccount.loadBalances();
+                this._accounts.set(nexaAccount.getAccountStoreKey(), nexaAccount);
+                return nexaAccount;
+        }
+    }
+    /**
+     * Finds the private key associated with a given address across all accounts
+     * @param address The address to search for
+     * @returns The AddressKey containing the private key, or null if not found
+     */ findKeyForAddress(address) {
+        // Search through all accounts
+        for (const [_, account] of this._accounts.entries()){
+            // Combine receive and change keys for this account
+            const allKeys = account.accountKeys.receiveKeys.concat(account.accountKeys.changeKeys);
+            // Check each key for a matching address
+            for (const key of allKeys){
+                if (key.address == address) return key;
+            }
+        }
+        return null;
+    }
+    /**
+     * Imports an existing account into the store
+     * @param accountData The account data to import
+     * @throws Error if an account with the same key already exists
+     */ importAccount(accountData) {
+        let index = accountData.getAccountStoreKey();
+        if (this._accounts.get(index)) throw Error('Account already exists!');
+        this._accounts.set(String(index), accountData);
+    }
+    /**
+     * Exports account data by index
+     * @param accountIndex The account index to export
+     * @returns The account data
+     * @throws Error if the account doesn't exist
+     */ exportAccount(accountIndex) {
+        if (!this._accounts.get(accountIndex)) throw Error('Cannot find account!');
+        return this._accounts.get(accountIndex);
+    }
+    /**
+     * Removes an account from the store
+     * @param accountIndex The account index to remove
+     * @throws Error if the account doesn't exist
+     */ removeAccount(accountIndex) {
+        if (!this._accounts.get(accountIndex)) throw Error('Cannot find account!');
+        this._accounts.delete(accountIndex);
+    }
+    /**
+     * Returns all accounts in the store
+     * @returns Map of account store keys to BaseAccount objects
+     */ listAccounts() {
+        return this._accounts;
+    }
+    /**
+     * Retrieves a specific account by its index
+     * @param index The account index to retrieve
+     * @returns The account if found, undefined otherwise
+     */ getAccount(index) {
+        return this._accounts.get(index);
+    }
+}
+
+
+
+class $8c756bc820fcaf73$export$2e2bcd8739ae039 {
+    /**
+     * Validate that a state condition is true
+     * 
+     * @param condition - The condition to validate
+     * @param message - Error message to throw if condition is false
+     * @throws {Error} If condition is false
+     * 
+     * @example
+     * ```typescript
+     * ValidationUtils.validateState(wallet.isInitialized, 'Wallet must be initialized');
+     * ```
+     */ static validateState(condition, message) {
+        if (!condition) throw new Error(`Invalid State: ${message}`);
+    }
+    /**
+     * Validate that an argument condition is true
+     * 
+     * @param condition - The condition to validate
+     * @param argumentName - Name of the argument being validated
+     * @param message - Optional additional error message
+     * @throws {Error} If condition is false
+     * 
+     * @example
+     * ```typescript
+     * ValidationUtils.validateArgument(
+     *   typeof amount === 'number',
+     *   'amount',
+     *   'must be a number'
+     * );
+     * ```
+     */ static validateArgument(condition, argumentName, message = "") {
+        if (!condition) throw new Error(`Invalid Argument: ${argumentName}. ${message}`);
+    }
+    /**
+     * Validate that an argument is of the expected type
+     * 
+     * @param argument - The argument to validate
+     * @param type - Expected type (string name or constructor function)
+     * @param argumentName - Name of the argument being validated
+     * @throws {TypeError} If argument is not of expected type
+     * 
+     * @example
+     * ```typescript
+     * ValidationUtils.validateArgumentType(buffer, 'Buffer', 'data');
+     * ValidationUtils.validateArgumentType(wallet, Wallet, 'wallet');
+     * ValidationUtils.validateArgumentType(amount, 'number', 'amount');
+     * ```
+     */ static validateArgumentType(argument, type, argumentName) {
+        argumentName = argumentName || '(unknown name)';
+        if ((0, $633cp$isString)(type)) {
+            if (type === 'Buffer') {
+                if (!Buffer.isBuffer(argument)) throw new TypeError(`Invalid Argument for ${argumentName}, expected ${type} but got ${typeof argument}`);
+            } else if (typeof argument !== type) throw new TypeError(`Invalid Argument for ${argumentName}, expected ${type} but got ${typeof argument}`);
+        } else {
+            if (!(argument instanceof type)) throw new TypeError(`Invalid Argument for ${argumentName}, expected ${type} but got ${typeof argument}`);
+        }
+    }
+}
+
+
+class $f2814d31d49d257b$export$2e2bcd8739ae039 {
+    /**
+     * Creates a new Wallet instance
+     *
+     * @param data - Optional wallet data:
+     *   - undefined: Generate new random seed phrase
+     *   - string: Use as BIP39 seed phrase
+     *   - HDPrivateKey: Use as master key directly
+     * @param network - Network name ('mainnet', 'testnet', 'regtest'). Defaults to 'mainnet'
+     *
+     * @example
+     * ```typescript
+     * // Create new wallet with random seed
+     * const wallet = new Wallet();
+     *
+     * // Create from seed phrase
+     * const wallet = new Wallet('abandon abandon abandon...');
+     *
+     * // Create from master key
+     * const masterKey = HDPrivateKey.fromString('xprv...');
+     * const wallet = new Wallet(masterKey);
+     *
+     * // Create on testnet
+     * const wallet = new Wallet(undefined, 'testnet');
+     * ```
+     */ constructor(data, network){
+        this._network = (0, $633cp$Networks).get(network) ?? (0, $633cp$Networks).mainnet;
+        this._accountStore = new (0, $f956f86dd8b9f336$export$2e2bcd8739ae039)();
+        if ((0, $633cp$isNil)(data)) {
+            this.phrase = $633cp$generateMnemonic(128, undefined, $633cp$wordlists.english);
+            const seed = $633cp$mnemonicToSeedSync(this.phrase, '');
+            const masterKey = (0, $633cp$HDPrivateKey).fromSeed(seed, this._network ?? (0, $633cp$Networks).mainnet);
+            this.masterKey = masterKey.deriveChild(44, true).deriveChild(29223, true);
+        } else if (data instanceof (0, $633cp$HDPrivateKey)) this.masterKey = data;
+        else if ((0, $633cp$isString)(data)) {
+            this.phrase = data;
+            const seed = $633cp$mnemonicToSeedSync(this.phrase, '');
+            const masterKey = (0, $633cp$HDPrivateKey).fromSeed(seed, this._network ?? (0, $633cp$Networks).mainnet);
+            this.masterKey = masterKey.deriveChild(44, true).deriveChild(29223, true);
+        }
+    }
+    /**
+     * Create a new wallet with a randomly generated seed phrase
+     *
+     * This is the recommended way to create a new wallet for first-time users.
+     * The generated seed phrase should be securely stored by the user.
+     *
+     * @returns A new Wallet instance with a random 12-word seed phrase
+     *
+     * @example
+     * ```typescript
+     * const wallet = Wallet.create();
+     * console.log(wallet.export().phrase); // Store this securely!
+     * ```
+     */ static create() {
+        return new $f2814d31d49d257b$export$2e2bcd8739ae039();
+    }
+    /**
+     * Create a wallet from an existing BIP39 seed phrase
+     *
+     * Use this method to restore a wallet from a previously generated seed phrase.
+     * The seed phrase should be a valid BIP39 mnemonic.
+     *
+     * @param phrase - The BIP39 seed phrase (12 or 24 words)
+     * @param network - Optional network name ('mainnet', 'testnet', 'regtest')
+     * @returns A new Wallet instance restored from the seed phrase
+     * @throws {Error} If the seed phrase is invalid or not provided
+     *
+     * @example
+     * ```typescript
+     * const wallet = Wallet.fromSeedPhrase(
+     *   'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+     *   'testnet'
+     * );
+     * ```
+     */ static fromSeedPhrase(phrase, network) {
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument((0, $633cp$isString)(phrase), 'seedphrase must be provided');
+        return new $f2814d31d49d257b$export$2e2bcd8739ae039(phrase, network);
+    }
+    /**
+     * Create a wallet from an extended private key (xpriv)
+     *
+     * Use this method to create a wallet from a master private key in extended format.
+     * This is useful for advanced users who want to use a specific key derivation.
+     *
+     * @param xpriv - The extended private key string (starts with 'xprv')
+     * @param network - Optional network name ('mainnet', 'testnet', 'regtest')
+     * @returns A new Wallet instance using the provided master key
+     * @throws {Error} If the private key is invalid or not provided
+     *
+     * @example
+     * ```typescript
+     * const wallet = Wallet.fromXpriv(
+     *   'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'
+     * );
+     * ```
+     */ static fromXpriv(xpriv, network) {
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument((0, $633cp$isString)(xpriv), 'private key must be provided');
+        const masterKey = (0, $633cp$HDPrivateKey).fromString(xpriv);
+        return new $f2814d31d49d257b$export$2e2bcd8739ae039(masterKey, network);
+    }
+    /**
+     * Initialize the wallet by discovering accounts and loading balances
+     *
+     * This method performs account discovery using the BIP44 derivation path
+     * and scans for existing accounts with transaction history or balances.
+     * Must be called before using the wallet's accounts.
+     *
+     * @returns Promise that resolves when initialization is complete
+     *
+     * @example
+     * ```typescript
+     * const wallet = Wallet.fromSeedPhrase('your seed phrase');
+     * await wallet.initialize();
+     *
+     * // Now you can access discovered accounts
+     * const accounts = wallet.accountStore.listAccounts();
+     * ```
+     */ async initialize() {
+        const walletAccounts = await (0, $f10b40ff0fa7ccfb$export$4e4f91181d6bd31c)(this.masterKey);
+        for (const account of walletAccounts)this._accountStore.importAccount(account);
+    }
+    /**
+     * Create a new transaction builder for this wallet
+     *
+     * @param fromAccount - The account to send the transaction from
+     * @param x - Optional existing transaction data:
+     *   - TransactionBuilder: Use existing transaction builder
+     *   - string: Parse from hex string
+     *   - Buffer: Parse from binary buffer
+     *   - undefined: Create new empty transaction
+     * @returns A new WalletTransactionCreator instance
+     *
+     * @example
+     * ```typescript
+     * const account = wallet.accountStore.getAccount(0);
+     * const tx = wallet.newTransaction(account)
+     *   .to('nexa:address', 1000000) // 1 NEXA
+     *   .sign();
+     *
+     * // Or from existing transaction hex
+     * const tx = wallet.newTransaction(account, 'raw_tx_hex')
+     *   .sign();
+     * ```
+     */ newTransaction(fromAccount, x) {
+        let tx;
+        if (x instanceof (0, $633cp$TransactionBuilder)) tx = new (0, $d9127651ccaae19d$export$2e2bcd8739ae039)(fromAccount, x);
+        else if ((0, $633cp$isString)(x)) tx = new (0, $d9127651ccaae19d$export$2e2bcd8739ae039)(fromAccount).parseTxHex(x);
+        else if ((0, $633cp$isBuffer)(x) && !(0, $633cp$isNil)(x)) tx = new (0, $d9127651ccaae19d$export$2e2bcd8739ae039)(fromAccount).parseTxBuffer(x);
+        else tx = new (0, $d9127651ccaae19d$export$2e2bcd8739ae039)(fromAccount);
+        return tx.onNetwork(this._network);
+    }
+    /**
+     * Create a new account for this wallet
+     *
+     * @param accountType - The type of account to create:
+     *   - 'DefaultAccount': Standard account for general use
+     *   - 'VaultAccount': Secured account with additional protection
+     *   - 'DappAccount': Account optimized for dApp interactions
+     * @returns Promise that resolves to the newly created account
+     *
+     * @example
+     * ```typescript
+     * const defaultAccount = await wallet.newAccount('DefaultAccount');
+     * const vaultAccount = await wallet.newAccount('VaultAccount');
+     * const dappAccount = await wallet.newAccount('DappAccount');
+     * ```
+     */ async newAccount(accountType) {
+        return await this.accountStore.createAccount(accountType, this.masterKey);
+    }
+    /**
+     * Broadcast a signed transaction to the Nexa network
+     *
+     * @param transaction - The signed transaction in hex format
+     * @returns Promise that resolves to the transaction ID (txid)
+     * @throws {Error} If the transaction is invalid or broadcast fails
+     *
+     * @example
+     * ```typescript
+     * const tx = wallet.newTransaction(account)
+     *   .to('nexa:address', 1000000)
+     *   .sign();
+     *
+     * const txId = await wallet.sendTransaction(tx.toHex());
+     * console.log('Transaction sent:', txId);
+     * ```
+     */ async sendTransaction(transaction) {
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument((0, $633cp$isString)(transaction), 'transaction must be present and valid');
+        return (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).broadcast(transaction);
+    }
+    /**
+     * Sign a message using a specific address from this wallet
+     *
+     * The message is signed using the private key associated with the given address.
+     * This can be used for authentication or to prove ownership of an address.
+     *
+     * @param message - The message to sign
+     * @param addressToUse - The address whose private key should sign the message
+     * @returns The signature as a base64-encoded string
+     * @throws {Error} If the address is not owned by this wallet
+     *
+     * @example
+     * ```typescript
+     * const account = wallet.accountStore.getAccount(0);
+     * const address = account.getReceiveAddress();
+     * const signature = wallet.signMessage('Hello World', address);
+     * ```
+     */ signMessage(message, addressToUse) {
+        let msg = new (0, $633cp$Message)(message);
+        const addressKey = this.accountStore.findKeyForAddress(addressToUse);
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument((0, $633cp$isNil)(addressKey), "You dont own this private key");
+        return msg.sign(addressKey?.key.privateKey);
+    }
+    /**
+     * Verify a message signature against an address
+     *
+     * This method can verify signatures created by any address, not just addresses
+     * owned by this wallet. It's useful for verifying messages from other parties.
+     *
+     * @param message - The original message that was signed
+     * @param signature - The signature to verify (base64-encoded)
+     * @param address - The address that supposedly signed the message
+     * @returns true if the signature is valid, false otherwise
+     * @throws {Error} If any parameters are missing or invalid
+     *
+     * @example
+     * ```typescript
+     * const isValid = wallet.verifyMessage(
+     *   'Hello World',
+     *   'signature_string',
+     *   'nexa:address'
+     * );
+     * console.log('Signature valid:', isValid);
+     * ```
+     */ verifyMessage(message, signature, address) {
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument(!(0, $633cp$isNil)(message), 'message is required');
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument(!(0, $633cp$isNil)(signature), 'signature is required');
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument(!(0, $633cp$isNil)(address), 'address is required ');
+        let msg = new (0, $633cp$Message)(message);
+        const addressKey = this.accountStore.findKeyForAddress(address);
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument((0, $633cp$isNil)(addressKey), "You dont own this private key");
+        return msg.verify(address, signature);
+    }
+    /**
+     * Export the wallet data for backup or storage
+     *
+     * Returns an object containing the wallet's seed phrase, master key, and accounts.
+     * This data can be used to restore the wallet later. The seed phrase should be
+     * stored securely as it provides full access to the wallet.
+     *
+     * @returns Object containing wallet data
+     * @property {string} phrase - The BIP39 seed phrase (if available)
+     * @property {HDPrivateKey} masterKey - The master private key
+     * @property {BaseAccount[]} accounts - Array of discovered accounts
+     *
+     * @example
+     * ```typescript
+     * const walletData = wallet.export();
+     *
+     * // Store the seed phrase securely
+     * const seedPhrase = walletData.phrase;
+     *
+     * // Later, restore the wallet
+     * const restoredWallet = Wallet.fromSeedPhrase(seedPhrase);
+     * ```
+     */ export() {
+        return {
+            phrase: this.phrase,
+            masterKey: this.masterKey,
+            accounts: this._accountStore.listAccounts(),
+            accountIndexes: this.accountStore.listAccounts().keys()
+        };
+    }
+    /**
+     * Get the account store for managing wallet accounts
+     *
+     * The account store provides methods to create, import, and manage accounts
+     * within this wallet. Each account has its own set of addresses and keys.
+     *
+     * @returns The wallet's account store
+     *
+     * @example
+     * ```typescript
+     * const accountStore = wallet.accountStore;
+     * const accounts = accountStore.listAccounts();
+     * const firstAccount = accountStore.getAccount(0);
+     * ```
+     */ get accountStore() {
+        return this._accountStore;
+    }
+    /**
+     * Get the network this wallet is operating on
+     *
+     * @returns The network object (mainnet, testnet, or regtest)
+     *
+     * @example
+     * ```typescript
+     * const network = wallet.network;
+     * console.log('Network:', network.name);
+     * ```
+     */ get network() {
+        return this._network;
+    }
+}
+
+
+
+
+
+
+
+
+
+const $d99d0d987374a56c$var$MAX_INPUTS_OUTPUTS = 250;
+async function $d99d0d987374a56c$export$20e004915450ed44(txBuilder, addresses, totalTxValue, options) {
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(addresses)) throw new Error("Not enough Nexa balance.");
+    let usedAddresses = new Set();
+    let origAmount = options.isConsolidate ? 0 : Number(totalTxValue);
+    for (let item of addresses){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getNexaUtxos(item.address);
+        for (let utxo of utxos){
+            let input = {
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value,
+                templateData: options.templateData
+            };
+            txBuilder.from(input);
+            if (!usedAddresses.has(item.address)) usedAddresses.add(item.address);
+            if (options.isConsolidate) {
+                // need to handle change
+                txBuilder.change(options.toChange ?? item.address);
+                if (txBuilder.transaction.inputs.length > $d99d0d987374a56c$var$MAX_INPUTS_OUTPUTS) return Array.from(usedAddresses.values());
+            } else {
+                let tx = txBuilder.transaction;
+                if (tx.inputs.length > $d99d0d987374a56c$var$MAX_INPUTS_OUTPUTS) throw new Error("Too many inputs. Consider consolidate transactions or reduce the send amount.");
+                let unspent = tx.getUnspentValue();
+                if (unspent < 0n) continue;
+                if (unspent == 0n && options.feeFromAmount) {
+                    let txFee = tx.estimateRequiredFee();
+                    tx.updateOutputAmount(0, origAmount - txFee);
+                    return Array.from(usedAddresses.values());
+                }
+                txBuilder.change(options.toChange ?? item.address);
+                if (options.feeFromAmount) {
+                    let hasChange = tx.getChangeOutput();
+                    let txFee = tx.estimateRequiredFee();
+                    tx.updateOutputAmount(0, origAmount - txFee);
+                    // edge case where change added after update
+                    if (!hasChange && tx.getChangeOutput()) {
+                        txFee = tx.estimateRequiredFee();
+                        tx.updateOutputAmount(0, origAmount - txFee);
+                    }
+                }
+                // check again after change output manipulation
+                if (tx.getUnspentValue() < tx.estimateRequiredFee()) continue;
+                return Array.from(usedAddresses.values());
+            }
+        }
+    }
+    if (options.isConsolidate) {
+        if (usedAddresses.size > 0) return Array.from(usedAddresses.values());
+        throw new Error("Not enough Nexa balance.");
+    }
+    let err = {
+        errorMsg: "Not enough Nexa balance.",
+        amount: (0, $633cp$UnitUtils).formatNEXA(Number(totalTxValue)),
+        fee: (0, $633cp$UnitUtils).formatNEXA(txBuilder.transaction.estimateRequiredFee())
+    };
+    throw new Error(JSON.stringify(err));
+}
+async function $d99d0d987374a56c$export$49bc96b87058cba4(txBuilder, addresses, token, outTokenAmount) {
+    if ((0, $424cf91992355440$export$c8733ae29fb53302)(addresses)) throw new Error("Not enough token balance.");
+    let usedKeys = new Set();
+    let inTokenAmount = 0n;
+    for (let item of addresses){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTokenUtxos(item.address, token);
+        for (let utxo of utxos){
+            if (utxo.token_amount < 0) continue;
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value,
+                groupId: utxo.group,
+                groupAmount: BigInt(utxo.token_amount)
+            });
+            inTokenAmount = inTokenAmount + BigInt(utxo.token_amount);
+            if (!usedKeys.has(item.address)) usedKeys.add(item.address);
+            if (inTokenAmount > (0, $424cf91992355440$export$8ba128bc85947a2a)) throw new Error("Token inputs exceeded max amount. Consider sending in small chunks");
+            if (txBuilder.transaction.inputs.length > $d99d0d987374a56c$var$MAX_INPUTS_OUTPUTS) throw new Error("Too many inputs. Consider consolidating transactions or reduce the send amount.");
+            if (inTokenAmount == outTokenAmount) return Array.from(usedKeys.values());
+            if (inTokenAmount > outTokenAmount) {
+                // change
+                txBuilder.to(item.address, (0, $633cp$Transaction).DUST_AMOUNT, token, inTokenAmount - outTokenAmount);
+                return Array.from(usedKeys.values());
+            }
+        }
+    }
+    throw new Error("Not enough token balance");
+}
+async function $d99d0d987374a56c$export$74e83de914f372c5(txBuilder, addresses, opReturnData, network) {
+    let outpoint = '', idHex = '';
+    let usedKeys = [];
+    for (let item of addresses){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getNexaUtxos(item.address);
+        for (let utxo of utxos){
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value
+            });
+            if ((0, $424cf91992355440$export$c8733ae29fb53302)(outpoint)) {
+                outpoint = utxo.outpoint_hash;
+                let id = (0, $633cp$GroupToken).findGroupId(Buffer.from(outpoint, 'hex'), Buffer.from(opReturnData, 'hex'), (0, $633cp$GroupToken).authFlags.ACTIVE_FLAG_BITS);
+                const groupId = new (0, $633cp$Address)(id.hashBuffer, network, (0, $633cp$AddressType).GroupIdAddress).toString();
+                txBuilder.to(item.address, (0, $633cp$Transaction).DUST_AMOUNT, groupId, (0, $633cp$GroupToken).authFlags.ACTIVE_FLAG_BITS | id.nonce);
+                idHex = id.hashBuffer.toString('hex');
+                usedKeys.push(item.address);
+                return usedKeys;
+            }
+        }
+    }
+    throw new Error("Not enough Nexa balance.");
+}
+async function $d99d0d987374a56c$export$1eb54f2f084fd3c6(txBuilder, addresses, outpoint) {
+    let utxo = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getUtxo(outpoint);
+    let address = utxo.addresses[0];
+    txBuilder.from({
+        outpoint: outpoint,
+        address: address,
+        satoshis: utxo.amount
+    });
+    let addrKey = addresses.find((k)=>k.address === address);
+    if (!addrKey) throw new Error('UTXO associated key not found in the wallet');
+    return [
+        addrKey.address
+    ];
+}
+async function $d99d0d987374a56c$export$d7c9c386067a6463(txBuilder, addresses, token, perm, subgroup = '') {
+    for (let item of addresses){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTokenUtxos(item.address, token);
+        for (let utxo of utxos){
+            if (!(0, $3091f185ded8655f$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) continue;
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value
+            });
+            if (perm === 'subgroup') txBuilder.to(item.address, (0, $633cp$Transaction).DUST_AMOUNT, subgroup, (0, $3091f185ded8655f$export$636fb0b03b94ac81)(utxo.token_amount, false));
+            // if renew flag included, we don't want to burn it
+            if ((0, $633cp$GroupToken).allowsRenew(BigInt.asUintN(64, BigInt(utxo.token_amount)))) txBuilder.to(item.address, (0, $633cp$Transaction).DUST_AMOUNT, token, (0, $3091f185ded8655f$export$636fb0b03b94ac81)(utxo.token_amount));
+            return [
+                item.address
+            ];
+        }
+    }
+    throw new Error("The requested authority not found");
+}
+async function $d99d0d987374a56c$export$5c44e04d8c04c292(txBuilder, addresses, token, perms, toAddr) {
+    let usedAddresses = [];
+    let reqiredPerms = new Set(perms);
+    reqiredPerms.add('authorise');
+    for (let item of addresses){
+        let utxos = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getTokenUtxos(item.address, token);
+        for (let utxo of utxos){
+            if (utxo.token_amount > 0) continue;
+            let found = false;
+            for (let perm of reqiredPerms)if ((0, $3091f185ded8655f$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) {
+                reqiredPerms.delete(perm);
+                found = true;
+            }
+            if (!found) continue;
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value
+            });
+            usedAddresses.push(item.address);
+            // duplicate
+            txBuilder.to(toAddr != null ? toAddr : item.address, (0, $633cp$Transaction).DUST_AMOUNT, token, (0, $3091f185ded8655f$export$636fb0b03b94ac81)(utxo.token_amount));
+            if (reqiredPerms.size === 0) return usedAddresses;
+        }
+    }
+    throw new Error("The required authorities not found");
+}
+
+
+
+
+
+class $b43c09fc4c8f3049$export$2e2bcd8739ae039 extends (0, $def4af748ddce85f$export$bba690fb5c12ba04) {
+    /**
+     * Creates a new WatchOnlyTransactionCreator
+     * @param tx Optional existing transaction builder or transaction data
+     */ constructor(tx){
+        super(tx), /** Addresses that need to be signed with (populated during transaction building) */ this._addressesToSignWith = [], /** Available addresses for input selection and change */ this._availableAddresses = [];
+    }
+    /**
+     * Sets the source addresses for transaction inputs
+     * @param address Single address string, array of addresses, or WatchOnlyAddress objects
+     * @returns This instance for chaining
+     */ from(address) {
+        if ((0, $633cp$isString)(address)) {
+            if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(address, this.network) && !(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(address, this.network, (0, $633cp$AddressType).PayToPublicKeyHash)) throw new Error('Invalid Address.');
+            // Single address string
+            this._availableAddresses.push({
+                address: address
+            });
+        } else if (Array.isArray(address)) // Array of addresses or WatchOnlyAddress objects
+        address.forEach((addr)=>{
+            if ((0, $633cp$isString)(addr)) {
+                if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(addr, this.network) && !(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(addr, this.network, (0, $633cp$AddressType).PayToPublicKeyHash)) throw new Error('Invalid Address.');
+                // String address
+                this._availableAddresses.push({
+                    address: addr
+                });
+            } else if (addr && typeof addr === 'object' && 'address' in addr) // WatchOnlyAddress object
+            this._availableAddresses.push(addr);
+        });
+        else if (address.address != null) // Single WatchOnlyAddress object
+        this._availableAddresses.push(address);
+        return this;
+    }
+    /**
+     * Adds a token minting operation to the transaction
+     * @param token Token ID to mint
+     * @param amount Amount to mint
+     * @param toAddr Destination address for minted tokens
+     * @returns This instance for chaining
+     */ mint(token, amount, toAddr) {
+        this.builder.push(async ()=>{
+            this.tokenAction(toAddr, amount, token, 'mint');
+        });
+        return this;
+    }
+    /**
+     * Adds a token melting operation to the transaction
+     * @param token Token ID to melt
+     * @param amount Amount to melt
+     * @param toAddr Destination address for melted tokens
+     * @returns This instance for chaining
+     */ melt(token, amount, toAddr) {
+        this.builder.push(async ()=>{
+            this.tokenAction(toAddr, amount, token, 'melt');
+        });
+        return this;
+    }
+    /**
+     * Populates the transaction with inputs and outputs based on the configured actions.
+     * Handles different token operations (mint, melt, group creation, etc.) and
+     * populates NEXA inputs for transaction fees.
+     * @returns This instance for chaining
+     */ populate() {
+        this.builder.push(async ()=>{
+            let tokenAddresses = [];
+            let nexaAddresses = [];
+            // Process token operations if any are configured
+            if (this.tokens.size > 0) for (const tokenAction of this.tokens){
+                if (tokenAction.action == 'mint' || tokenAction.action == 'melt') // Handle token minting/melting - requires authority
+                tokenAddresses = tokenAddresses.concat(await (0, $d99d0d987374a56c$export$d7c9c386067a6463)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.action));
+                else if (tokenAction.action == 'group') // Handle group token creation
+                tokenAddresses = tokenAddresses.concat(await (0, $d99d0d987374a56c$export$74e83de914f372c5)(this.transactionBuilder, this._availableAddresses, tokenAction.token, this.network));
+                else if (tokenAction.action == 'subgroup') // Handle subgroup token creation
+                tokenAddresses = tokenAddresses.concat(await (0, $d99d0d987374a56c$export$d7c9c386067a6463)(this.transactionBuilder, this._availableAddresses, tokenAction.parentToken, tokenAction.action, tokenAction.token));
+                else if (tokenAction.action == 'renew') // Handle authority renewal
+                tokenAddresses = tokenAddresses.concat(await (0, $d99d0d987374a56c$export$5c44e04d8c04c292)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.extraData.perms, tokenAction.extraData?.address));
+                else if (tokenAction.action == 'delete') // Handle authority deletion
+                tokenAddresses = tokenAddresses.concat(await (0, $d99d0d987374a56c$export$1eb54f2f084fd3c6)(this.transactionBuilder, this._availableAddresses, tokenAction.extraData.outpoint));
+                else // Handle regular token transfers
+                tokenAddresses = tokenAddresses.concat(await (0, $d99d0d987374a56c$export$49bc96b87058cba4)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.amount));
+                // Accumulate addresses that need signing
+                this._addressesToSignWith.concat(tokenAddresses);
+            }
+            // Populate NEXA inputs for transaction fees and change
+            nexaAddresses = nexaAddresses.concat(await (0, $d99d0d987374a56c$export$20e004915450ed44)(this.transactionBuilder, this._availableAddresses, this.totalValue, this.txOptions));
+            // Combine all addresses that need signing
+            this._addressesToSignWith = tokenAddresses.concat(nexaAddresses);
+        });
+        return this;
+    }
+    /**
+     * Parse transaction from buffer (not implemented for watch-only)
+     * @param tx Transaction buffer
+     * @returns This instance for chaining
+     * @throws Error indicating method not implemented
+     */ parseTxBuffer(tx) {
+        this.builder.push(async ()=>{
+            this.transactionBuilder = new (0, $633cp$TransactionBuilder)(tx);
+        });
+        return this;
+    }
+    /**
+     * Parse transaction from hex string (not implemented for watch-only)
+     * @param tx Transaction hex string
+     * @returns This instance for chaining
+     * @throws Error indicating method not implemented
+     */ parseTxHex(tx) {
+        this.builder.push(async ()=>{
+            const txBuilder = new (0, $633cp$TransactionBuilder)(tx);
+            const newTxBuilder = new (0, $633cp$TransactionBuilder)();
+            const oldInputs = txBuilder.transaction.inputs;
+            for (const input of oldInputs){
+                const utxo = await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).getUtxo(input.outpoint.toString('hex'));
+                newTxBuilder.from({
+                    outpoint: utxo.tx_hash,
+                    amount: utxo.amount,
+                    scriptPubKey: utxo.scriptpubkey
+                });
+            }
+            newTxBuilder.transaction.outputs = txBuilder.transaction.outputs;
+            this.transactionBuilder = newTxBuilder;
+        });
+        return this;
+    }
+}
+
+
+
+
+
+
+class $426a9fb8db44c326$export$2e2bcd8739ae039 {
+    /**
+     * Creates a new WatchOnlyWallet instance
+     * @param addressesToWatch Array of addresses to monitor
+     * @param network Optional network name (defaults to mainnet)
+     * @throws Error if validation fails
+     */ constructor(addressesToWatch, network){
+        // Validate network parameter
+        if (network !== undefined && !(0, $633cp$isString)(network)) throw new Error('Network must be a string');
+        if (network !== undefined && (0, $633cp$isString)(network)) {
+            const n = (0, $633cp$Networks).get(network);
+            if (n === undefined) throw new Error(`Invalid network: ${network}`);
+        }
+        this._network = (0, $633cp$Networks).get(network) ?? (0, $633cp$Networks).mainnet;
+        // Validate addressesToWatch parameter
+        this._addressesToWatch = this.validateAddressesToWatch(addressesToWatch);
+    }
+    /**
+     * Validates the addresses to watch array
+     * @param addressesToWatch Array of addresses to validate
+     * @returns Validated array of WatchOnlyAddress objects
+     * @throws Error if validation fails
+     */ validateAddressesToWatch(addressesToWatch) {
+        if (addressesToWatch === null || addressesToWatch === undefined) throw new Error('addresesToWatch is required');
+        if (!(0, $633cp$isArray)(addressesToWatch)) throw new Error('addressesToWatch must be an array');
+        // Check if array is not empty
+        if (addressesToWatch.length === 0) throw new Error('addressesToWatch cannot be empty');
+        // Validate each address object
+        const validatedAddresses = [];
+        for(let i = 0; i < addressesToWatch.length; i++){
+            const addr = addressesToWatch[i];
+            // Check if address is an object
+            if (!(0, $633cp$isObject)(addr) || (0, $633cp$isArray)(addr)) throw new Error(`addressesToWatch[${i}] must be an object`);
+            // Check if address property exists and is a string
+            if (!addr.hasOwnProperty('address') || !(0, $633cp$isString)(addr.address)) throw new Error(`addressesToWatch[${i}].address must be a string`);
+            // Check if address is not empty
+            if (addr.address.trim() === '') throw new Error(`addressesToWatch[${i}].address cannot be empty`);
+            // Validate address format
+            if (!(0, $f10b40ff0fa7ccfb$export$8d986bd2866fe6ab)(addr.address, this._network)) throw new Error(`addressesToWatch[${i}].address is not a valid NEXA address: ${addr.address}`);
+            // Validate optional xPub property
+            if (addr.xPub !== undefined && !(0, $633cp$isObject)(addr.xPub)) throw new Error(`addressesToWatch[${i}].xPub must be a PublicKey object`);
+            // Validate optional derivationPath property
+            if (addr.derivationPath !== undefined && !(0, $633cp$isString)(addr.derivationPath)) throw new Error(`addressesToWatch[${i}].derivationPath must be a string`);
+            // Check for duplicate addresses
+            const isDuplicate = validatedAddresses.some((existingAddr)=>existingAddr.address === addr.address);
+            if (isDuplicate) throw new Error(`Duplicate address found: ${addr.address}`);
+            validatedAddresses.push({
+                address: addr.address.trim(),
+                xPub: addr.xPub,
+                derivationPath: addr.derivationPath
+            });
+        }
+        return validatedAddresses;
+    }
+    /**
+     * Creates a new transaction creator for this watch-only wallet
+     * @param x Optional transaction data - can be a TransactionBuilder, hex string, or Buffer
+     * @returns WatchOnlyTransactionCreator configured with wallet's addresses and network
+     */ newTransaction(x) {
+        let tx;
+        // Handle different input types for creating transactions
+        if (x instanceof (0, $633cp$TransactionBuilder)) // Use existing TransactionBuilder instance
+        tx = new (0, $b43c09fc4c8f3049$export$2e2bcd8739ae039)(x);
+        else if ((0, $633cp$isString)(x)) // Parse transaction from hex string
+        tx = new (0, $b43c09fc4c8f3049$export$2e2bcd8739ae039)().parseTxHex(x);
+        else if ((0, $633cp$isBuffer)(x) && !(0, $633cp$isNil)(x)) // Parse transaction from buffer
+        tx = new (0, $b43c09fc4c8f3049$export$2e2bcd8739ae039)().parseTxBuffer(x);
+        else // Create new empty transaction
+        tx = new (0, $b43c09fc4c8f3049$export$2e2bcd8739ae039)();
+        // Configure transaction with wallet's addresses and network
+        return tx.from(this._addressesToWatch).onNetwork(this._network);
+    }
+    /**
+     * Broadcasts a signed transaction to the network
+     * @param transaction Hex-encoded signed transaction
+     * @returns Promise resolving to transaction ID
+     * @throws Error if transaction is invalid or broadcast fails
+     */ async sendTransaction(transaction) {
+        (0, $8c756bc820fcaf73$export$2e2bcd8739ae039).validateArgument((0, $633cp$isString)(transaction), 'transaction must be present and valid');
+        return (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).broadcast(transaction);
+    }
+    async subscribeToAddressNotifications(callback) {
+        await (0, $30c92dd8e96ca60d$export$eaa49f0478d81b9d).subscribeToAddresses(this._addressesToWatch.map((addr)=>addr.address), callback);
+    }
+    /**
+     * Gets the list of addresses being watched
+     * @returns Array of watched addresses (copy to prevent mutation)
+     */ getWatchedAddresses() {
+        return [
+            ...this._addressesToWatch
+        ];
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Guards against multiple instances of the wallet SDK being loaded.
+ * This prevents conflicts and ensures only one version is active at a time.
+ * @param version - The version string to check
+ * @throws {Error} When multiple instances are detected
+ */ function $5cbb3ff6642afc2e$var$versionGuard(version) {
+    if (version !== undefined) {
+        let message = "More than one instance of Wallet SDKPlease make sure to require Wallet SDK and check that submodules do not also include their own Wallet SDK dependency.";
+        throw new Error(message);
+    }
+}
+$5cbb3ff6642afc2e$var$versionGuard($parcel$global._walletSdk_ver);
+$parcel$global._walletSdk_ver = `v${0, $bbe36848c5b6746e$exports.version}`;
+/**
+ * Wallet SDK - A TypeScript SDK for the Nexa blockchain
+ *
+ * This SDK provides comprehensive wallet functionality including:
+ * - Creating and managing wallets from seed phrases or private keys
+ * - Account management with different account types
+ * - Transaction building and signing
+ * - Token operations and management
+ * - Message signing and verification
+ *
+ * @example
+ * ```typescript
+ * import { Wallet } from 'wallet-sdk-ts';
+ *
+ * // Create a new wallet
+ * const wallet = Wallet.create();
+ *
+ * // Or restore from seed phrase
+ * const wallet = Wallet.fromSeedPhrase('your seed phrase here');
+ *
+ * // Initialize and discover accounts
+ * await wallet.initialize();
+ * ```
+ */ const $5cbb3ff6642afc2e$var$walletSdk = {
+    versionGuard: $5cbb3ff6642afc2e$var$versionGuard,
+    version: `v${(0, $bbe36848c5b6746e$exports.version)}`,
+    Wallet: $f2814d31d49d257b$export$2e2bcd8739ae039
+};
+var $5cbb3ff6642afc2e$export$2e2bcd8739ae039 = $5cbb3ff6642afc2e$var$walletSdk;
+
+
+export {$5cbb3ff6642afc2e$export$2e2bcd8739ae039 as default, $f2814d31d49d257b$export$2e2bcd8739ae039 as Wallet, $426a9fb8db44c326$export$2e2bcd8739ae039 as WatchOnlyWallet, $f10b40ff0fa7ccfb$export$b8ca5fa4899cbfc7 as AccountType, $f10b40ff0fa7ccfb$export$dcc1fb6ad5308e56 as TxTokenType, $51649cc8d0caebe5$export$c54c8796e94a37a0 as BaseAccount, $3213756e8a8eb72f$export$2e2bcd8739ae039 as DefaultAccount, $5ef3d149a7ae4b51$export$2e2bcd8739ae039 as DappAccount, $fcf0a0849682f4b5$export$2e2bcd8739ae039 as VaultAccount, $f956f86dd8b9f336$export$2e2bcd8739ae039 as AccountStore, $d9127651ccaae19d$export$2e2bcd8739ae039 as WalletTransactionCreator, $b43c09fc4c8f3049$export$2e2bcd8739ae039 as WatchOnlyTransactionCreator, $30c92dd8e96ca60d$export$eaa49f0478d81b9d as rostrumProvider};
+//# sourceMappingURL=index.mjs.map