nexa-wallet-sdk 0.4.2 → 0.5.1

package/dist/index.cjs

@@ -149,7 +149,7 @@ $parcel$export(module.exports, "SighashType", () => $l50U0$libnexats.SighashType
 $parcel$export(module.exports, "AccountKeysUtils", () => $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6);
 // @ts-ignore
 var $2dd241e44b9dc3c2$exports = {};
-$2dd241e44b9dc3c2$exports = JSON.parse("{\"name\":\"nexa-wallet-sdk\",\"version\":\"0.4.2\",\"type\":\"module\",\"source\":\"src/index.ts\",\"types\":\"dist/index.d.ts\",\"main\":\"dist/index.cjs\",\"module\":\"dist/index.mjs\",\"browser\":\"dist/index.web.mjs\",\"exports\":{\"types\":\"./dist/index.d.ts\",\"node\":{\"import\":\"./dist/index.mjs\",\"require\":\"./dist/index.cjs\"},\"browser\":\"./dist/index.web.mjs\",\"default\":\"./dist/index.mjs\"},\"scripts\":{\"build\":\"parcel build\",\"lint\":\"eslint .\",\"fix-lint\":\"eslint --fix .\",\"dev\":\"parcel watch\",\"test\":\"vitest run\",\"clean\":\"rm -rf dist .parcel-cache\",\"docs\":\"typedoc\",\"docs:serve\":\"typedoc && npx serve docs -l 8080\",\"docs:mkdocs\":\"typedoc && mkdocs serve\",\"docs:build\":\"typedoc && mkdocs build\",\"docs:setup\":\"./scripts/setup-docs.sh\",\"wallet-cli\":\"node examples/wallet-cli.cjs\"},\"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\",\"eslint\":\"^9.20.1\",\"parcel\":\"^2.15.4\",\"typedoc\":\"^0.28.7\",\"typedoc-plugin-markdown\":\"^4.7.0\",\"typedoc-plugin-rename-defaults\":\"^0.7.3\",\"typescript\":\"^5.8.3\",\"typescript-eslint\":\"^8.24.1\",\"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\",\"prompt-sync\":\"^4.2.0\",\"wallet-comms-sdk\":\"^0.6.0\"},\"files\":[\"dist\"],\"directories\":{\"test\":\"tests\"},\"@parcel/resolver-default\":{\"packageExports\":true}}");
+$2dd241e44b9dc3c2$exports = JSON.parse("{\"name\":\"nexa-wallet-sdk\",\"version\":\"0.5.1\",\"type\":\"module\",\"source\":\"src/index.ts\",\"types\":\"dist/index.d.ts\",\"main\":\"dist/index.cjs\",\"module\":\"dist/index.mjs\",\"browser\":\"dist/index.web.mjs\",\"exports\":{\"types\":\"./dist/index.d.ts\",\"node\":{\"import\":\"./dist/index.mjs\",\"require\":\"./dist/index.cjs\"},\"browser\":\"./dist/index.web.mjs\",\"default\":\"./dist/index.mjs\"},\"scripts\":{\"build\":\"parcel build\",\"lint\":\"eslint .\",\"fix-lint\":\"eslint --fix .\",\"dev\":\"parcel watch\",\"test\":\"vitest run\",\"clean\":\"rm -rf dist .parcel-cache\",\"docs\":\"typedoc\",\"docs:serve\":\"typedoc && npx serve docs -l 8080\",\"docs:mkdocs\":\"typedoc && mkdocs serve\",\"docs:build\":\"typedoc && mkdocs build\",\"docs:setup\":\"./scripts/setup-docs.sh\",\"wallet-cli\":\"node examples/wallet-cli.cjs\"},\"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\",\"eslint\":\"^9.20.1\",\"parcel\":\"^2.15.4\",\"typedoc\":\"^0.28.7\",\"typedoc-plugin-markdown\":\"^4.7.0\",\"typedoc-plugin-rename-defaults\":\"^0.7.3\",\"typescript\":\"^5.8.3\",\"typescript-eslint\":\"^8.24.1\",\"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\",\"prompt-sync\":\"^4.2.0\",\"wallet-comms-sdk\":\"^0.6.1\"},\"files\":[\"dist\"],\"directories\":{\"test\":\"tests\"},\"@parcel/resolver-default\":{\"packageExports\":true}}");
 
 
 
@@ -651,6 +651,11 @@ function $bc5ca2c06b1affa3$export$254a5c7330bbfd41(token) {
     if ((0, $l50U0$libnexats.CommonUtils).isHexa(token)) return token;
     return $bc5ca2c06b1affa3$export$23010fd5dda8dec1(token).toString('hex');
 }
+function $bc5ca2c06b1affa3$export$f12d707d2b261fb6(txIdem, outputIndex) {
+    const writer = new (0, $l50U0$libnexats.BufferWriter)(undefined);
+    const outpoint = writer.write(Buffer.from(txIdem, 'hex').reverse()).writeUInt32LE(outputIndex).toBuffer();
+    return (0, $l50U0$libnexats.Hash).sha256(outpoint).reverse().toString('hex');
+}
 
 
 var $0d59d2bcffd646c5$export$dcc1fb6ad5308e56 = /*#__PURE__*/ function(TxTokenType) {
@@ -1291,7 +1296,6 @@ var $90290c84737dbb50$export$2e2bcd8739ae039 = $90290c84737dbb50$var$isString;
 
 
 
-
 class $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6 {
     static getAllKeys(keys) {
         return keys.receiveKeys.concat(keys.changeKeys);
@@ -1358,7 +1362,7 @@ function $22e282633cad8f97$export$e240c810a53c3a0c(perms) {
 
 
 /** Maximum number of inputs/outputs allowed in a single transaction */ const $b4a043612f1c4089$var$MAX_INPUTS_OUTPUTS = 250;
-async function $b4a043612f1c4089$export$afd979971a55acfc(txBuilder, keys, totalTxValue, options) {
+async function $b4a043612f1c4089$export$afd979971a55acfc(txBuilder, keys, totalTxValue, options, spentOutpoints) {
     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);
@@ -1368,6 +1372,8 @@ async function $b4a043612f1c4089$export$afd979971a55acfc(txBuilder, keys, totalT
     for (let key of allKeys){
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getNexaUtxos(key.address);
         for (let utxo of utxos){
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             let input = {
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
@@ -1375,6 +1381,8 @@ async function $b4a043612f1c4089$export$afd979971a55acfc(txBuilder, keys, totalT
                 templateData: options.templateData
             };
             txBuilder.from(input);
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             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);
@@ -1418,7 +1426,7 @@ async function $b4a043612f1c4089$export$afd979971a55acfc(txBuilder, keys, totalT
     };
     throw new Error(JSON.stringify(err));
 }
-async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token, outTokenAmount) {
+async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token, outTokenAmount, spentOutpoints) {
     let tokenHex = (0, $bc5ca2c06b1affa3$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));
@@ -1430,6 +1438,8 @@ async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token,
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(key.address, token);
         for (let utxo of utxos){
             if (utxo.token_amount < 0) continue;
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
@@ -1437,6 +1447,8 @@ async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token,
                 groupId: utxo.group,
                 groupAmount: BigInt(utxo.token_amount)
             });
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             inTokenAmount = inTokenAmount + BigInt(utxo.token_amount);
             if (!usedKeys.has(key.address)) usedKeys.set(key.address, key.key.privateKey);
             if (inTokenAmount > (0, $bc5ca2c06b1affa3$export$8ba128bc85947a2a)) throw new Error("Token inputs exceeded max amount. Consider sending in small chunks");
@@ -1452,7 +1464,7 @@ async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token,
     }
     throw new Error("Not enough token balance");
 }
-async function $b4a043612f1c4089$export$d7f2b844e1d59768(txBuilder, keys, opReturnData, network) {
+async function $b4a043612f1c4089$export$d7f2b844e1d59768(txBuilder, keys, opReturnData, network, spentOutpoints) {
     // TODO validate opreturn data
     const allKeys = (0, $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6).getAllKeys(keys);
     let outpoint = '';
@@ -1461,11 +1473,15 @@ async function $b4a043612f1c4089$export$d7f2b844e1d59768(txBuilder, keys, opRetu
     for (let key of allKeys){
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getNexaUtxos(key.address);
         for (let utxo of utxos){
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
                 satoshis: utxo.value
             });
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             if ((0, $bc5ca2c06b1affa3$export$c8733ae29fb53302)(outpoint)) {
                 outpoint = utxo.outpoint_hash;
                 let id = (0, $l50U0$libnexats.GroupToken).findGroupId(outpoint, Buffer.from(opReturnData, 'hex'), (0, $l50U0$libnexats.GroupToken).authFlags.ACTIVE_FLAG_BITS);
@@ -1494,17 +1510,21 @@ async function $b4a043612f1c4089$export$48a48877d6df17e9(txBuilder, keys, outpoi
         addrKey.key.privateKey
     ];
 }
-async function $b4a043612f1c4089$export$1dfa5d829fc95097(txBuilder, keys, token, perm, subgroup = '', subgroupAddr = '', quantity) {
+async function $b4a043612f1c4089$export$1dfa5d829fc95097(txBuilder, keys, token, perm, subgroup = '', subgroupAddr = '', quantity, spentOutpoints) {
     let allKeys = (0, $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6).getAllKeys(keys);
     for (let key of allKeys){
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(key.address, token);
         for (let utxo of utxos){
             if (!(0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) continue;
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
                 satoshis: utxo.value
             });
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             if (perm === 'subgroup') {
                 const subgroupQuantity = quantity ?? (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount, false);
                 txBuilder.to(subgroupAddr, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, subgroup, subgroupQuantity);
@@ -1521,7 +1541,7 @@ async function $b4a043612f1c4089$export$1dfa5d829fc95097(txBuilder, keys, token,
     }
     throw new Error("The requested authority not found");
 }
-async function $b4a043612f1c4089$export$28a843ca046a6b3f(txBuilder, keys, token, perms, toAddr) {
+async function $b4a043612f1c4089$export$28a843ca046a6b3f(txBuilder, keys, token, perms, toAddr, spentOutpoints) {
     let allKeys = (0, $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6).getAllKeys(keys);
     let usedKeys = [];
     let reqiredPerms = new Set(perms);
@@ -1530,6 +1550,8 @@ async function $b4a043612f1c4089$export$28a843ca046a6b3f(txBuilder, keys, token,
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(key.address, token);
         for (let utxo of utxos){
             if (utxo.token_amount > 0) continue;
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             let found = false;
             for (let perm of reqiredPerms)if ((0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) {
                 reqiredPerms.delete(perm);
@@ -1542,6 +1564,8 @@ async function $b4a043612f1c4089$export$28a843ca046a6b3f(txBuilder, keys, token,
                 satoshis: utxo.value
             });
             usedKeys.push(key.key.privateKey);
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             // duplicate
             const duplicateAddress = toAddr != null ? toAddr : keys.changeKeys.length > 0 ? keys.changeKeys[keys.changeKeys.length - 1].address : keys.receiveKeys[keys.receiveKeys.length - 1].address;
             txBuilder.to(duplicateAddress, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount));
@@ -1680,6 +1704,7 @@ var $ed110f8656071ee4$export$2e2bcd8739ae039 = $ed110f8656071ee4$var$parseInt;
 
 
 
+
 class $57b0117fe8233fef$export$bba690fb5c12ba04 {
     /**
      * Creates a new TransactionCreator instance
@@ -1689,10 +1714,80 @@ class $57b0117fe8233fef$export$bba690fb5c12ba04 {
         /** Total value of NEXA being sent in this transaction */ this._totalValue = BigInt(0);
         /** Network this transaction will be broadcast on */ this._network = (0, $l50U0$libnexats.Networks).mainnet;
         /** Transaction options for customizing behavior */ this._txOptions = {};
+        /** Set of outpoints already spent in this transaction to prevent double-spending */ this._spentOutpoints = new Set();
         if (tx instanceof (0, $l50U0$libnexats.TransactionBuilder)) this.transactionBuilder = tx;
         this.tokens = new Set();
         this.transactionBuilder = new (0, $l50U0$libnexats.TransactionBuilder)();
     }
+    /**
+     * Parse transaction from hex string with common logic
+     * @param tx Transaction hex string
+     * @returns This instance for chaining
+     */ parseTxHex(tx) {
+        // Clear any existing builder operations since we're dealing with a pre-built transaction
+        this.builder = [];
+        // Add the parsing operation to the builder queue
+        this.builder.push(async ()=>{
+            try {
+                const txBuilder = new (0, $l50U0$libnexats.TransactionBuilder)(tx);
+                const newTxBuilder = new (0, $l50U0$libnexats.TransactionBuilder)();
+                const oldInputs = txBuilder.transaction.inputs;
+                // Reconstruct inputs with proper script template data if needed
+                for(let i = 0; i < oldInputs.length; i++){
+                    const input = oldInputs[i];
+                    const utxo = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getUtxo(input.outpoint.toString('hex'));
+                    const scriptPubkey = (0, $l50U0$libnexats.Script).fromHex(utxo.scriptpubkey);
+                    if (scriptPubkey.isScriptTemplateOut()) {
+                        const scriptSig = input.scriptSig;
+                        newTxBuilder.transaction.addInput(new (0, $l50U0$libnexats.ScriptTemplateInput)({
+                            amount: input.amount,
+                            outpoint: input.outpoint.toString('hex'),
+                            scriptSig: input.scriptSig,
+                            templateData: {
+                                templateScript: (0, $l50U0$libnexats.BufferUtils).isHashBuffer(scriptPubkey.getTemplateHash()) ? (0, $l50U0$libnexats.Script).fromBuffer(scriptSig.chunks[0].buf) : (0, $l50U0$libnexats.Script).empty(),
+                                constraintScript: (0, $l50U0$libnexats.BufferUtils).isHashBuffer(scriptPubkey.getConstraintHash()) ? (0, $l50U0$libnexats.Script).fromBuffer(scriptSig.chunks[1].buf) : (0, $l50U0$libnexats.Opcode).OP_FALSE
+                            },
+                            output: {
+                                type: input.type,
+                                value: utxo.amount,
+                                scriptPubKey: utxo.scriptpubkey
+                            }
+                        }));
+                    } else // For non-template inputs, add them normally
+                    newTxBuilder.from({
+                        outpoint: input.outpoint.toString('hex'),
+                        satoshis: input.amount,
+                        address: utxo.addresses[0],
+                        scriptPubKey: utxo.scriptpubkey
+                    });
+                    // Hook for subclasses to handle input-specific logic (like key management)
+                    await this.handleParsedInput(input, utxo, i);
+                }
+                // Copy the outputs from the original transaction
+                newTxBuilder.transaction.outputs = txBuilder.transaction.outputs;
+                this.transactionBuilder = newTxBuilder;
+                // Hook for subclasses to perform post-processing
+                await this.handleParsingComplete();
+            } catch (error) {
+                console.error('parseTxHex: Error parsing transaction:', error);
+                throw error;
+            }
+        });
+        return this;
+    }
+    /**
+     * Hook for subclasses to handle individual parsed inputs
+     * @param input The original input from the transaction
+     * @param utxo UTXO data for this input
+     * @param index Input index
+     */ async handleParsedInput(input, utxo, index) {
+    // Default implementation does nothing - subclasses can override
+    }
+    /**
+     * Hook for subclasses to perform post-processing after parsing is complete
+     */ async handleParsingComplete() {
+    // Default implementation does nothing - subclasses can override
+    }
     /**
      * Sets the network for this transaction
      * @param network Network name or Networkish object
@@ -1737,6 +1832,17 @@ class $57b0117fe8233fef$export$bba690fb5c12ba04 {
     /** Sets the total NEXA value being sent */ set totalValue(value) {
         this._totalValue = value;
     }
+    /** Gets the set of spent outpoints */ get spentOutpoints() {
+        return this._spentOutpoints;
+    }
+    /**
+     * Updates the spent outpoints set with current transaction inputs
+     * @returns Set of outpoint hashes that are already spent
+     */ updateSpentOutpoints() {
+        this._spentOutpoints.clear();
+        for (const input of this.transactionBuilder.transaction.inputs)this._spentOutpoints.add(input.outpoint.toString('hex'));
+        return this._spentOutpoints;
+    }
     /**
      * Validates and creates a token action
      * @param toAddr Destination address
@@ -1789,10 +1895,27 @@ class $57b0117fe8233fef$export$bba690fb5c12ba04 {
      * @param toAddr Destination address
      * @param amount Amount of tokens to send
      * @param token Token ID
+     * @param dustAmount Optional dust amount for the output (defaults to Transaction.DUST_AMOUNT)
      * @returns This instance for chaining
-     */ sendToToken(toAddr, amount, token) {
+     */ sendToToken(toAddr, amount, token, dustAmount = (0, $l50U0$libnexats.Transaction).DUST_AMOUNT) {
         this.builder.push(async ()=>{
-            this.tokenAction(toAddr, amount, token, 'send');
+            // Validate destination address
+            if (!(0, $0d59d2bcffd646c5$export$8d986bd2866fe6ab)(toAddr, this.network) && !(0, $0d59d2bcffd646c5$export$8d986bd2866fe6ab)(toAddr, this.network, (0, $l50U0$libnexats.AddressType).PayToPublicKeyHash)) throw new Error('Invalid Address.');
+            // Validate amount ranges
+            if (BigInt(amount) < 1n) throw new Error("The amount is too low.");
+            if (BigInt(amount) > (0, $bc5ca2c06b1affa3$export$8ba128bc85947a2a)) throw new Error("The amount is too high.");
+            // Validate token ID
+            if (!(0, $0d59d2bcffd646c5$export$8d986bd2866fe6ab)(token, this.network, (0, $l50U0$libnexats.AddressType).GroupIdAddress)) throw new Error('Invalid Token ID');
+            // Ensure tokens are sent to script template addresses
+            if ((0, $l50U0$libnexats.Address).getOutputType(toAddr) === 0) throw new Error('Token must be sent to script template address');
+            // Add output to transaction with configurable dust amount
+            this.transactionBuilder.to(toAddr, dustAmount, token, BigInt(amount));
+            // Record the token action
+            this.tokens.add({
+                token: token,
+                amount: BigInt(amount),
+                action: 'send'
+            });
         });
         return this;
     }
@@ -1941,9 +2064,10 @@ class $57b0117fe8233fef$export$bba690fb5c12ba04 {
             let opReturn = (0, $l50U0$libnexats.ScriptFactory).buildNFTDescription(zipUrl, zipHash);
             this.transactionBuilder.addData(opReturn, true);
             // generate subgroup ID
-            const subGroup = (0, $l50U0$libnexats.GroupToken).generateSubgroupId(parent, opReturn.toBuffer()).toString('hex');
+            const subGroupBuffer = (0, $l50U0$libnexats.GroupToken).generateSubgroupId(parent, zipHash);
+            const subGroupAddress = new (0, $l50U0$libnexats.Address)(subGroupBuffer, (0, $l50U0$libnexats.Networks).get(this.network) || (0, $l50U0$libnexats.Networks).mainnet, (0, $l50U0$libnexats.AddressType).GroupIdAddress).toString();
             this.tokens.add({
-                token: subGroup,
+                token: subGroupAddress,
                 parentToken: parent,
                 amount: BigInt((0, $l50U0$libnexats.Transaction).DUST_AMOUNT),
                 action: 'subgroup',
@@ -1967,9 +2091,10 @@ class $57b0117fe8233fef$export$bba690fb5c12ba04 {
             let opReturn = (0, $l50U0$libnexats.ScriptFactory).buildNFTDescription(zipUrl, zipHash);
             this.transactionBuilder.addData(opReturn, true);
             // generate subgroup ID
-            const subGroup = (0, $l50U0$libnexats.GroupToken).generateSubgroupId(parent, opReturn.toBuffer()).toString('hex');
+            const subGroupBuffer = (0, $l50U0$libnexats.GroupToken).generateSubgroupId(parent, zipHash);
+            const subGroupAddress = new (0, $l50U0$libnexats.Address)(subGroupBuffer, (0, $l50U0$libnexats.Networks).get(this.network) || (0, $l50U0$libnexats.Networks).mainnet, (0, $l50U0$libnexats.AddressType).GroupIdAddress).toString();
             this.tokens.add({
-                token: subGroup,
+                token: subGroupAddress,
                 parentToken: parent,
                 amount: BigInt((0, $l50U0$libnexats.Transaction).DUST_AMOUNT),
                 action: 'subgroup',
@@ -2034,28 +2159,33 @@ class $e1896e59040fa3c5$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
         return this;
     }
     parseTxHex(tx) {
-        this.builder.push(async ()=>{
-            const txBuilder = new (0, $l50U0$libnexats.TransactionBuilder)(tx);
-            const newTxBuilder = new (0, $l50U0$libnexats.TransactionBuilder)();
-            const oldInputs = txBuilder.transaction.inputs;
-            for (const input of oldInputs){
-                const utxo = await (0, $b5bfd17fdf06d231$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;
+        // Call parent's parseTxHex which handles the common parsing logic
+        return super.parseTxHex(tx);
+    }
+    /**
+     * Handle wallet-specific logic for each parsed input (find and store private keys)
+     */ async handleParsedInput(input, utxo, index) {
+        // Find and store the private key for this input
+        const foundKey = this.findPrivateKeyFromAddress(utxo.addresses[0]);
+        if (foundKey) this._keysToSign.push(foundKey.key.privateKey);
+    }
+    /**
+     * Handle wallet-specific post-processing after parsing is complete
+     */ async handleParsingComplete() {
+        // If no keys found, use the primary account key as fallback
+        if (this._keysToSign.length == 0) this._keysToSign.push(this._account.getPrimaryAddressKey().key.privateKey);
     }
     parseTxBuffer(tx) {
-        this.builder.push(async ()=>{
-            this.transactionBuilder = new (0, $l50U0$libnexats.TransactionBuilder)(tx);
-        });
+        // Clear any existing builder operations since we're dealing with a pre-built transaction
+        this.builder = [];
+        // For buffer, we can parse immediately since it doesn't require async operations
+        this.transactionBuilder = new (0, $l50U0$libnexats.TransactionBuilder)(tx);
+        // Extract all possible keys from the account that might be needed for signing
+        // Since we don't have UTXO data, we'll add all account keys
+        const addresses = this._account.getAddresses();
+        for (const addressKey of addresses)if (!this._keysToSign.includes(addressKey.key.privateKey)) this._keysToSign.push(addressKey.key.privateKey);
+        // If no keys found, use the primary account key as fallback
+        if (this._keysToSign.length == 0) this._keysToSign.push(this._account.getPrimaryAddressKey().key.privateKey);
         return this;
     }
     mint(token, amount) {
@@ -2078,63 +2208,236 @@ class $e1896e59040fa3c5$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
             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, $b4a043612f1c4089$export$1dfa5d829fc95097)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.action));
-                else if (tokenAction.action == 'group') tK = tK.concat(await (0, $b4a043612f1c4089$export$d7f2b844e1d59768)(this.transactionBuilder, this._account.accountKeys, tokenAction.extraData?.opReturnData, this.network));
-                else if (tokenAction.action == 'subgroup') tK = tK.concat(await (0, $b4a043612f1c4089$export$1dfa5d829fc95097)(this.transactionBuilder, this._account.accountKeys, tokenAction.parentToken, 'subgroup', tokenAction.token, this._account.accountKeys.receiveKeys.at(-1).address, tokenAction.extraData?.quantity));
-                else if (tokenAction.action == 'renew') tK = tK.concat(await (0, $b4a043612f1c4089$export$28a843ca046a6b3f)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.extraData.perms, tokenAction.extraData.address));
+                if (tokenAction.action == 'mint' || tokenAction.action == 'melt') tK = tK.concat(await (0, $b4a043612f1c4089$export$1dfa5d829fc95097)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.action, undefined, undefined, undefined, this.spentOutpoints));
+                else if (tokenAction.action == 'group') tK = tK.concat(await (0, $b4a043612f1c4089$export$d7f2b844e1d59768)(this.transactionBuilder, this._account.accountKeys, tokenAction.extraData?.opReturnData, this.network, this.spentOutpoints));
+                else if (tokenAction.action == 'subgroup') tK = tK.concat(await (0, $b4a043612f1c4089$export$1dfa5d829fc95097)(this.transactionBuilder, this._account.accountKeys, tokenAction.parentToken, 'subgroup', tokenAction.token, this._account.accountKeys.receiveKeys.at(-1).address, tokenAction.extraData?.quantity, this.spentOutpoints));
+                else if (tokenAction.action == 'renew') tK = tK.concat(await (0, $b4a043612f1c4089$export$28a843ca046a6b3f)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.extraData.perms, tokenAction.extraData.address, this.spentOutpoints));
                 else if (tokenAction.action == 'delete') tK = tK.concat(await (0, $b4a043612f1c4089$export$48a48877d6df17e9)(this.transactionBuilder, this._account.accountKeys, tokenAction.extraData.outpoint));
-                else tK = tK.concat(await (0, $b4a043612f1c4089$export$931e37acdaa22dcf)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.amount));
+                else tK = tK.concat(await (0, $b4a043612f1c4089$export$931e37acdaa22dcf)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.amount, this.spentOutpoints));
                 this._keysToSign.concat(tK);
             }
-            nK = nK.concat(await (0, $b4a043612f1c4089$export$afd979971a55acfc)(this.transactionBuilder, this._account.accountKeys, this.totalValue, this.txOptions));
+            nK = nK.concat(await (0, $b4a043612f1c4089$export$afd979971a55acfc)(this.transactionBuilder, this._account.accountKeys, this.totalValue, this.txOptions, this.spentOutpoints));
             this._keysToSign = tK.concat(nK);
         });
         return this;
     }
     sign() {
         this.builder.push(async ()=>{
-            const blockHeight = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getBlockTip();
-            this.transactionBuilder.lockUntilBlockHeight(blockHeight.height).sign(this._keysToSign);
+            // Process each transaction input using placeholder-based signing
+            const inputs = this.transactionBuilder.transaction.inputs;
+            for(let inputIndex = 0; inputIndex < inputs.length; inputIndex++){
+                const input = inputs[inputIndex];
+                // Analyze the scriptSig to determine signing strategy
+                const analysis = this.analyzeScriptSig(input.scriptSig);
+                if (analysis.strategy === 'skip') {
+                    console.log(`Skipping input ${inputIndex} - no placeholder found`);
+                    continue;
+                }
+                // Determine sighash type from placeholder bytes (or default to SIGHASH_ALL)
+                const sighashType = analysis.sighashType || new (0, $l50U0$libnexats.SighashType)();
+                // Try signing with all available keys until one works
+                let signed = false;
+                const allAddressKeys = this._account.getAddresses();
+                for (const addressKey of allAddressKeys)try {
+                    // Sign the input
+                    const sig = (0, $l50U0$libnexats.TxSigner).sign(this.transactionBuilder.transaction, inputIndex, sighashType, this.transactionBuilder.transaction.inputs[inputIndex].getSubscript(), addressKey.key.privateKey);
+                    // Create signature buffer (Schnorr signature for Nexa)
+                    const signatureBuffer = new (0, $l50U0$libnexats.TxSignature)({
+                        publicKey: addressKey.key.publicKey,
+                        sigType: sighashType,
+                        signature: sig,
+                        subscript: this.transactionBuilder.transaction.inputs[inputIndex].getSubscript(),
+                        inputIndex: inputIndex
+                    }).toTxSatisfier();
+                    if (analysis.strategy === 'sign_all') this.transactionBuilder.signInput(inputIndex, addressKey.key.privateKey, sighashType);
+                    else if (analysis.strategy === 'replace_placeholder' && analysis.placeholderIndex !== undefined) {
+                        // Handle script template with mixed satisfier elements
+                        if (input instanceof (0, $l50U0$libnexats.ScriptTemplateInput) && analysis.satisfierElements && analysis.satisfierElements.length > 0) {
+                            // Reconstruct script template with preserved satisfier elements plus signature
+                            const templateInput = input;
+                            const allSatisfierElements = [
+                                ...analysis.satisfierElements
+                            ];
+                            // Insert signature at the correct position (where placeholder was)
+                            const relativeIndex = analysis.placeholderIndex - 2; // Adjust for template and constraint chunks
+                            allSatisfierElements.splice(relativeIndex, 0, signatureBuffer);
+                            this.transactionBuilder.transaction.inputs[inputIndex].scriptSig = this.buildScriptSig(templateInput.templateScript, templateInput.constraintScript, allSatisfierElements);
+                        } else if (input instanceof (0, $l50U0$libnexats.ScriptTemplateInput)) {
+                            // Script template with only placeholder (no other satisfier elements)
+                            const templateInput = input;
+                            this.transactionBuilder.transaction.inputs[inputIndex].scriptSig = this.buildScriptSig(templateInput.templateScript, templateInput.constraintScript, [
+                                signatureBuffer
+                            ]);
+                        } else // P2PKH script: signature placeholder + public key
+                        this.transactionBuilder.transaction.inputs[inputIndex].scriptSig = (0, $l50U0$libnexats.ScriptFactory).buildPublicKeyHashIn(addressKey.key.publicKey, sig);
+                    }
+                    signed = true;
+                    break;
+                } catch (error) {
+                // console.log(`Key for address ${addressKey.address} failed to sign input ${inputIndex}:`, (error as Error).message)
+                }
+                signed;
+            }
         });
         return this;
     }
+    buildSatisfier(elements) {
+        let script = new (0, $l50U0$libnexats.Script)();
+        for (const element of elements)script = script.add(element);
+        return script;
+    }
+    buildScriptSig(template, constraint, satisfierElements) {
+        const satisfierScript = this.buildSatisfier(satisfierElements);
+        return (0, $l50U0$libnexats.ScriptFactory).buildScriptTemplateIn(template, constraint, satisfierScript);
+    }
     /**
-     * Sign the transaction with specific sighash specification for inputs/outputs
-     * @param sighashSpec - Specification of which inputs and outputs to sign
-     * @returns This instance for chaining
-     */ signWithSpec(sighashSpec) {
-        this.builder.push(async ()=>{
-            const blockHeight = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getBlockTip();
-            this.transactionBuilder.lockUntilBlockHeight(blockHeight.height);
-            // If sighashSpec is provided, use selective signing
-            if (sighashSpec) {
-                // Parse sighashSpec and create appropriate SighashType
-                const sighashType = this.parseSighashSpec(sighashSpec);
-                // Sign each input with the specified sighash type
-                for(let i = 0; i < this._keysToSign.length; i++)if (this._keysToSign[i]) this.transactionBuilder.signInput(i, this._keysToSign[i], sighashType);
-            } else // Fall back to default signing if no spec provided
-            this.transactionBuilder.sign(this._keysToSign);
-        });
-        return this;
+     * Check if a buffer is a 64-byte placeholder (all zeros)
+     * @param buf - Buffer to check
+     * @returns true if it's a 64-byte zero placeholder
+     */ isPlaceholder(buf) {
+        if (!buf || buf.length < 64) return false;
+        const placeholderBytes = Buffer.alloc(64, 0);
+        return buf.subarray(0, 64).equals(placeholderBytes);
     }
     /**
-     * Parse sighash specification into SighashType instance
-     * @param sighashSpec - The sighash specification from wallet-comms-sdk
-     * @returns SighashType instance
-     */ parseSighashSpec(sighashSpec) {
-        // If sighashSpec is already a SighashType, return it
-        if (sighashSpec instanceof (0, $l50U0$libnexats.SighashType)) return sighashSpec;
-        // Create new SighashType based on specification
+     * Extract sighash type from placeholder buffer (bytes after the 64-byte placeholder)
+     * @param buf - Buffer that may contain sighash type after placeholder
+     * @returns SighashType or null if using default SIGHASH_ALL (empty sighash = 0)
+     */ extractSighashFromPlaceholder(buf) {
+        if (buf.length <= 64) // Empty SigHash - use single byte 0 (sign all inputs and outputs)
+        return (0, $l50U0$libnexats.SighashType).ALL; // Use default SIGHASH_ALL
+        // Parse the sighash bytes starting at offset 64
+        const sighashBytes = buf.subarray(64);
+        if (sighashBytes.length === 0) return (0, $l50U0$libnexats.SighashType).ALL; // Default SIGHASH_ALL
+        // Get the sighashtype flag byte
+        const flagByte = sighashBytes[0];
+        // Upper 4 bits = input type, Lower 4 bits = output type
+        const inputType = flagByte >> 4 & 0x0F;
+        const outputType = flagByte & 0x0F;
         const sighashType = new (0, $l50U0$libnexats.SighashType)();
-        // Handle the v0.6.0 format with inType, outType, inData, outData
-        if (typeof sighashSpec === 'object' && sighashSpec !== null) {
-            if (sighashSpec.inType !== undefined) sighashType.inType = sighashSpec.inType;
-            if (sighashSpec.outType !== undefined) sighashType.outType = sighashSpec.outType;
-            if (sighashSpec.inData !== undefined) sighashType.inData = sighashSpec.inData;
-            if (sighashSpec.outData !== undefined) sighashType.outData = sighashSpec.outData;
+        let byteIndex = 1;
+        // Parse input type flags
+        switch(inputType){
+            case 0:
+                sighashType.inType = 0; // ALL
+                break;
+            case 1:
+                sighashType.inType = 1; // FIRST_N
+                if (byteIndex < sighashBytes.length) {
+                    sighashType.inData = [
+                        sighashBytes[byteIndex]
+                    ];
+                    byteIndex++;
+                }
+                break;
+            case 2:
+                sighashType.inType = 2; // THIS
+                break;
+            default:
+                // Unknown input type, default to ALL
+                sighashType.inType = 0;
+        }
+        // Parse output type flags
+        switch(outputType){
+            case 0:
+                sighashType.outType = 0; // ALL
+                break;
+            case 1:
+                sighashType.outType = 1; // FIRST_N
+                if (byteIndex < sighashBytes.length) {
+                    sighashType.outData = [
+                        sighashBytes[byteIndex]
+                    ];
+                    byteIndex++;
+                }
+                break;
+            case 2:
+                sighashType.outType = 2; // TWO_OUTPUTS (if supported)
+                const outData = [];
+                if (byteIndex < sighashBytes.length) {
+                    outData.push(sighashBytes[byteIndex]);
+                    byteIndex++;
+                }
+                if (byteIndex < sighashBytes.length) {
+                    outData.push(sighashBytes[byteIndex]);
+                    byteIndex++;
+                }
+                sighashType.outData = outData;
+                break;
+            default:
+                // Unknown output type, default to ALL
+                sighashType.outType = 0;
         }
-        // If no valid sighash data was parsed, default to ALL
-        return sighashType.isInvalid() ? (0, $l50U0$libnexats.SighashType).ALL : sighashType;
+        return sighashType;
+    }
+    /**
+     * Determine signing behavior based on scriptSig content
+     * @param scriptSig - The scriptSig to analyze
+     * @returns Object with signing strategy and sighash type
+     */ analyzeScriptSig(scriptSig) {
+        const chunks = scriptSig.chunks;
+        // Empty scriptSig - sign with SIGHASH_ALL
+        if (chunks.length === 0) return {
+            strategy: 'sign_all',
+            sighashType: (0, $l50U0$libnexats.SighashType).ALL
+        };
+        // Single chunk
+        if (chunks.length === 1) {
+            const chunk = chunks[0];
+            if (chunk.buf && this.isPlaceholder(chunk.buf)) {
+                // Single placeholder - treat same as empty, sign with SIGHASH_ALL or extract sighash
+                const sighashType = this.extractSighashFromPlaceholder(chunk.buf);
+                return {
+                    strategy: 'sign_all',
+                    sighashType: sighashType
+                };
+            }
+            // Single non-placeholder chunk - skip signing
+            return {
+                strategy: 'skip',
+                sighashType: null
+            };
+        }
+        // For script templates, check if this follows the 3-part structure: template, constraint, satisfier elements
+        // If chunks.length >= 3, assume it's a script template where chunks[2:] are satisfier elements
+        if (chunks.length >= 3) {
+            // Extract satisfier elements (chunks starting from index 2)
+            const satisfierElements = [];
+            let placeholderIndex;
+            let sighashType = null;
+            for(let i = 2; i < chunks.length; i++){
+                const chunk = chunks[i];
+                if (chunk.buf && this.isPlaceholder(chunk.buf)) {
+                    // Found placeholder in satisfier elements
+                    placeholderIndex = i;
+                    sighashType = this.extractSighashFromPlaceholder(chunk.buf);
+                } else // Non-placeholder satisfier element - preserve it
+                satisfierElements.push(chunk);
+            }
+            if (placeholderIndex !== undefined) return {
+                strategy: 'replace_placeholder',
+                sighashType: sighashType,
+                placeholderIndex: placeholderIndex,
+                satisfierElements: satisfierElements
+            };
+        }
+        // Multiple chunks - look for placeholder (fallback for non-template scripts)
+        for(let i = 0; i < chunks.length; i++){
+            const chunk = chunks[i];
+            if (chunk.buf && this.isPlaceholder(chunk.buf)) {
+                const sighashType = this.extractSighashFromPlaceholder(chunk.buf);
+                return {
+                    strategy: 'replace_placeholder',
+                    sighashType: sighashType,
+                    placeholderIndex: i
+                };
+            }
+        }
+        // Multiple chunks without placeholder - skip signing
+        return {
+            strategy: 'skip',
+            sighashType: null
+        };
     }
     /**
      * Validates that the account has the necessary keys before performing operations
@@ -2184,10 +2487,14 @@ class $7fcf3b163a95e69a$export$2e2bcd8739ae039 {
      * 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
+     * @param forceNextIndex If true, forces the next sequential index regardless of blockchain usage
      * @returns Promise resolving to the created account
-     */ async createAccount(accountType, masterKey) {
-        // Get the next available index for this account type
-        const nextIndex = await (0, $0d59d2bcffd646c5$export$ef13479e8d3251d7)(accountType, masterKey);
+     */ async createAccount(accountType, masterKey, forceNextIndex = false) {
+        let nextIndex;
+        if (forceNextIndex) // Force next sequential index considering both blockchain and store
+        nextIndex = await this.getNextSequentialIndex(accountType, masterKey);
+        else // Get the next available index for this account type (discovery-based)
+        nextIndex = await (0, $0d59d2bcffd646c5$export$ef13479e8d3251d7)(accountType, masterKey);
         const accountStoreKey = this.getAccountStoreKey(accountType, nextIndex);
         // Check if account already exists
         const indexExists = this._accounts.get(String(accountStoreKey));
@@ -2298,6 +2605,41 @@ class $7fcf3b163a95e69a$export$2e2bcd8739ae039 {
         }
         return accounts;
     }
+    /**
+     * Gets the next sequential index for an account type, considering both blockchain
+     * discovery and accounts already in the store
+     * @param accountType The account type to get the next index for
+     * @param masterKey Master HD private key for blockchain discovery
+     * @returns Promise resolving to the next safe sequential index
+     */ async getNextSequentialIndex(accountType, masterKey) {
+        // First, get the discovery-based index (what exists on blockchain)
+        const discoveryIndex = await (0, $0d59d2bcffd646c5$export$ef13479e8d3251d7)(accountType, masterKey);
+        // Then, check what's the next index based on current store
+        const storeBasedIndex = this.getNextStoreIndex(accountType);
+        // Use whichever is higher to ensure we don't conflict with either
+        return Math.max(discoveryIndex, storeBasedIndex);
+    }
+    /**
+     * Gets the next index based only on accounts currently in the store
+     * @param accountType The account type to check
+     * @returns The next available index in the store
+     */ getNextStoreIndex(accountType) {
+        const indexes = [];
+        for (const [key, _] of this._accounts)switch(accountType){
+            case (0, $0d59d2bcffd646c5$export$b8ca5fa4899cbfc7).DAPP_ACCOUNT:
+                if (key.startsWith('2.')) indexes.push(parseInt(key.split('.')[1]));
+                break;
+            case (0, $0d59d2bcffd646c5$export$b8ca5fa4899cbfc7).VAULT_ACCOUNT:
+                if (key.startsWith('1.')) indexes.push(parseInt(key.split('.')[1]));
+                break;
+            case (0, $0d59d2bcffd646c5$export$b8ca5fa4899cbfc7).NEXA_ACCOUNT:
+                if (!key.includes('.')) indexes.push(parseInt(key));
+                break;
+        }
+        if (indexes.length === 0) return 0; // First account of this type
+        // Return the next sequential index after the highest existing one
+        return Math.max(...indexes) + 1;
+    }
 }
 
 
@@ -2389,6 +2731,7 @@ class $b76d3bd5024ccfc0$export$2e2bcd8739ae039 {
      * const wallet = new Wallet(undefined, 'testnet');
      * ```
      */ constructor(data, network){
+        /** Whether to force sequential account indexing instead of discovery-based indexing */ this._forceSequentialIndexing = false;
         this._network = (0, $l50U0$libnexats.Networks).get(network) ?? (0, $l50U0$libnexats.Networks).mainnet;
         this._accountStore = new (0, $7fcf3b163a95e69a$export$2e2bcd8739ae039)();
         if ((0, $54dde1e65fb8e5b8$export$2e2bcd8739ae039)(data)) {
@@ -2542,7 +2885,7 @@ class $b76d3bd5024ccfc0$export$2e2bcd8739ae039 {
      * const dappAccount = await wallet.newAccount('DappAccount');
      * ```
      */ async newAccount(accountType) {
-        return await this.accountStore.createAccount(accountType, this.masterKey);
+        return await this.accountStore.createAccount(accountType, this.masterKey, this._forceSequentialIndexing);
     }
     /**
      * Broadcast a signed transaction to the Nexa network
@@ -2760,6 +3103,47 @@ class $b76d3bd5024ccfc0$export$2e2bcd8739ae039 {
      */ get network() {
         return this._network;
     }
+    /**
+     * Get the current sequential indexing setting
+     *
+     * @returns true if forcing sequential indexing, false if using discovery-based indexing
+     *
+     * @example
+     * ```typescript
+     * const isSequential = wallet.forceSequentialIndexing;
+     * console.log('Sequential indexing:', isSequential);
+     * ```
+     */ get forceSequentialIndexing() {
+        return this._forceSequentialIndexing;
+    }
+    /**
+     * Set whether to force sequential account indexing
+     *
+     * When enabled, new accounts will use sequential indexes (0, 1, 2, ...) regardless
+     * of blockchain activity. This is useful for multi-user wallets where each user
+     * needs a unique account even if they haven't used it yet.
+     *
+     * When disabled (default), account creation uses discovery-based indexing which
+     * scans the blockchain for existing activity before assigning indexes.
+     *
+     * @param force - true to force sequential indexing, false for discovery-based
+     *
+     * @example
+     * ```typescript
+     * // Enable sequential indexing for multi-user scenarios
+     * wallet.forceSequentialIndexing = true;
+     *
+     * // Create accounts - they'll be 2.0, 2.1, 2.2 regardless of usage
+     * const alice = await wallet.newAccount(AccountType.DAPP_ACCOUNT);
+     * const bob = await wallet.newAccount(AccountType.DAPP_ACCOUNT);
+     * const charlie = await wallet.newAccount(AccountType.DAPP_ACCOUNT);
+     *
+     * // Disable for normal discovery-based indexing
+     * wallet.forceSequentialIndexing = false;
+     * ```
+     */ set forceSequentialIndexing(force) {
+        this._forceSequentialIndexing = force;
+    }
 }
 
 
@@ -2771,13 +3155,15 @@ class $b76d3bd5024ccfc0$export$2e2bcd8739ae039 {
 
 
 const $52632971edbdb934$var$MAX_INPUTS_OUTPUTS = 250;
-async function $52632971edbdb934$export$20e004915450ed44(txBuilder, addresses, totalTxValue, options) {
+async function $52632971edbdb934$export$20e004915450ed44(txBuilder, addresses, totalTxValue, options, spentOutpoints) {
     if ((0, $bc5ca2c06b1affa3$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, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getNexaUtxos(item.address);
         for (let utxo of utxos){
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             let input = {
                 outpoint: utxo.outpoint_hash,
                 address: item.address,
@@ -2785,6 +3171,8 @@ async function $52632971edbdb934$export$20e004915450ed44(txBuilder, addresses, t
                 templateData: options.templateData
             };
             txBuilder.from(input);
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             if (!usedAddresses.has(item.address)) usedAddresses.add(item.address);
             if (options.isConsolidate) {
                 // need to handle change
@@ -2828,7 +3216,7 @@ async function $52632971edbdb934$export$20e004915450ed44(txBuilder, addresses, t
     };
     throw new Error(JSON.stringify(err));
 }
-async function $52632971edbdb934$export$49bc96b87058cba4(txBuilder, addresses, token, outTokenAmount) {
+async function $52632971edbdb934$export$49bc96b87058cba4(txBuilder, addresses, token, outTokenAmount, spentOutpoints) {
     if ((0, $bc5ca2c06b1affa3$export$c8733ae29fb53302)(addresses)) throw new Error("Not enough token balance.");
     let usedKeys = new Set();
     let inTokenAmount = 0n;
@@ -2836,6 +3224,8 @@ async function $52632971edbdb934$export$49bc96b87058cba4(txBuilder, addresses, t
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(item.address, token);
         for (let utxo of utxos){
             if (utxo.token_amount < 0) continue;
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: item.address,
@@ -2843,6 +3233,8 @@ async function $52632971edbdb934$export$49bc96b87058cba4(txBuilder, addresses, t
                 groupId: utxo.group,
                 groupAmount: BigInt(utxo.token_amount)
             });
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             inTokenAmount = inTokenAmount + BigInt(utxo.token_amount);
             if (!usedKeys.has(item.address)) usedKeys.add(item.address);
             if (inTokenAmount > (0, $bc5ca2c06b1affa3$export$8ba128bc85947a2a)) throw new Error("Token inputs exceeded max amount. Consider sending in small chunks");
@@ -2857,17 +3249,21 @@ async function $52632971edbdb934$export$49bc96b87058cba4(txBuilder, addresses, t
     }
     throw new Error("Not enough token balance");
 }
-async function $52632971edbdb934$export$74e83de914f372c5(txBuilder, addresses, opReturnData, network) {
+async function $52632971edbdb934$export$74e83de914f372c5(txBuilder, addresses, opReturnData, network, spentOutpoints) {
     let outpoint = '';
     let usedKeys = [];
     for (let item of addresses){
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getNexaUtxos(item.address);
         for (let utxo of utxos){
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: item.address,
                 satoshis: utxo.value
             });
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             if ((0, $bc5ca2c06b1affa3$export$c8733ae29fb53302)(outpoint) && !utxo.has_token) {
                 outpoint = utxo.outpoint_hash;
                 let id = (0, $l50U0$libnexats.GroupToken).findGroupId(outpoint, Buffer.from(opReturnData, 'hex'), (0, $l50U0$libnexats.GroupToken).authFlags.ACTIVE_FLAG_BITS);
@@ -2894,16 +3290,20 @@ async function $52632971edbdb934$export$1eb54f2f084fd3c6(txBuilder, addresses, o
         addrKey.address
     ];
 }
-async function $52632971edbdb934$export$d7c9c386067a6463(txBuilder, addresses, token, perm, subgroup = '', quantity) {
+async function $52632971edbdb934$export$d7c9c386067a6463(txBuilder, addresses, token, perm, subgroup = '', quantity, spentOutpoints) {
     for (let item of addresses){
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(item.address, token);
         for (let utxo of utxos){
             if (!(0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) continue;
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: item.address,
                 satoshis: utxo.value
             });
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             if (perm === 'subgroup') {
                 const subgroupQuantity = quantity ?? (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount, false);
                 txBuilder.to(item.address, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, subgroup, subgroupQuantity);
@@ -2917,7 +3317,7 @@ async function $52632971edbdb934$export$d7c9c386067a6463(txBuilder, addresses, t
     }
     throw new Error("The requested authority not found");
 }
-async function $52632971edbdb934$export$5c44e04d8c04c292(txBuilder, addresses, token, perms, toAddr) {
+async function $52632971edbdb934$export$5c44e04d8c04c292(txBuilder, addresses, token, perms, toAddr, spentOutpoints) {
     let usedAddresses = [];
     let reqiredPerms = new Set(perms);
     reqiredPerms.add('authorise');
@@ -2925,6 +3325,8 @@ async function $52632971edbdb934$export$5c44e04d8c04c292(txBuilder, addresses, t
         let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(item.address, token);
         for (let utxo of utxos){
             if (utxo.token_amount > 0) continue;
+            // Skip if this outpoint is already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             let found = false;
             for (let perm of reqiredPerms)if ((0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, perm)) {
                 reqiredPerms.delete(perm);
@@ -2937,6 +3339,8 @@ async function $52632971edbdb934$export$5c44e04d8c04c292(txBuilder, addresses, t
                 satoshis: utxo.value
             });
             usedAddresses.push(item.address);
+            // Add to spent outpoints set
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
             // duplicate
             txBuilder.to(toAddr != null ? toAddr : item.address, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount));
             if (reqiredPerms.size === 0) return usedAddresses;
@@ -2948,7 +3352,6 @@ async function $52632971edbdb934$export$5c44e04d8c04c292(txBuilder, addresses, t
 
 
 
-
 class $2ce5b75d10954bb1$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$export$bba690fb5c12ba04) {
     /**
      * Creates a new WatchOnlyTransactionCreator
@@ -3018,22 +3421,22 @@ class $2ce5b75d10954bb1$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
             // 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, $52632971edbdb934$export$d7c9c386067a6463)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.action));
+                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$d7c9c386067a6463)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.action, undefined, undefined, this.spentOutpoints));
                 else if (tokenAction.action == 'group') // Handle group token creation
-                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$74e83de914f372c5)(this.transactionBuilder, this._availableAddresses, tokenAction.extraData?.opReturnData, this.network));
+                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$74e83de914f372c5)(this.transactionBuilder, this._availableAddresses, tokenAction.extraData?.opReturnData, this.network, this.spentOutpoints));
                 else if (tokenAction.action == 'subgroup') // Handle subgroup token creation
-                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$d7c9c386067a6463)(this.transactionBuilder, this._availableAddresses, tokenAction.parentToken, tokenAction.action, tokenAction.token, tokenAction.extraData?.quantity));
+                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$d7c9c386067a6463)(this.transactionBuilder, this._availableAddresses, tokenAction.parentToken, tokenAction.action, tokenAction.token, tokenAction.extraData?.quantity, this.spentOutpoints));
                 else if (tokenAction.action == 'renew') // Handle authority renewal
-                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$5c44e04d8c04c292)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.extraData.perms, tokenAction.extraData?.address));
+                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$5c44e04d8c04c292)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.extraData.perms, tokenAction.extraData?.address, this.spentOutpoints));
                 else if (tokenAction.action == 'delete') // Handle authority deletion
                 tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$1eb54f2f084fd3c6)(this.transactionBuilder, this._availableAddresses, tokenAction.extraData.outpoint));
                 else // Handle regular token transfers
-                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$49bc96b87058cba4)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.amount));
+                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$49bc96b87058cba4)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.amount, this.spentOutpoints));
                 // Accumulate addresses that need signing
                 this._addressesToSignWith.concat(tokenAddresses);
             }
             // Populate NEXA inputs for transaction fees and change
-            nexaAddresses = nexaAddresses.concat(await (0, $52632971edbdb934$export$20e004915450ed44)(this.transactionBuilder, this._availableAddresses, this.totalValue, this.txOptions));
+            nexaAddresses = nexaAddresses.concat(await (0, $52632971edbdb934$export$20e004915450ed44)(this.transactionBuilder, this._availableAddresses, this.totalValue, this.txOptions, this.spentOutpoints));
             // Combine all addresses that need signing
             this._addressesToSignWith = tokenAddresses.concat(nexaAddresses);
         });
@@ -3051,27 +3454,21 @@ class $2ce5b75d10954bb1$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
         return this;
     }
     /**
-     * Parse transaction from hex string (not implemented for watch-only)
+     * Parse transaction from hex string using enhanced base class implementation
      * @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, $l50U0$libnexats.TransactionBuilder)(tx);
-            const newTxBuilder = new (0, $l50U0$libnexats.TransactionBuilder)();
-            const oldInputs = txBuilder.transaction.inputs;
-            for (const input of oldInputs){
-                const utxo = await (0, $b5bfd17fdf06d231$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;
+        // Call parent's parseTxHex which handles script template reconstruction
+        return super.parseTxHex(tx);
+    }
+    /**
+     * Handle watch-only specific logic for each parsed input (track addresses for signing)
+     */ async handleParsedInput(_input, utxo, _index) {
+        // Track addresses that will need to be signed with external wallet
+        if (utxo.addresses && utxo.addresses.length > 0) {
+            const address = utxo.addresses[0];
+            if (!this._addressesToSignWith.includes(address)) this._addressesToSignWith.push(address);
+        }
     }
 }
 
@@ -3250,6 +3647,39 @@ const $7af6fdca1cf5d9d6$export$618de809a659cb44 = {
 };
 
 
+/**
+ * Extract all token outputs and amounts from transaction hex
+ * @param txHex - Transaction hex string
+ * @param network - Network to use for token address creation
+ * @returns Array of token outputs with tokenId and amount
+ */ const $23698d921173fdf9$var$getTokenOutputsFromTx = (txHex, network)=>{
+    const tokenOutputs = [];
+    try {
+        const transaction = new (0, $l50U0$libnexats.Transaction)(txHex);
+        for (const output of transaction.outputs)if (output.type !== 0 && output.scriptPubKey.chunks[0]?.opcodenum >= 32) {
+            const tokenIdHex = output.scriptPubKey.chunks[0].buf?.toString('hex');
+            if (tokenIdHex && output.scriptPubKey.chunks[1]?.buf) {
+                const tokenAddress = (0, $l50U0$libnexats.Address).fromObject({
+                    data: tokenIdHex,
+                    network: network.toString(),
+                    type: (0, $l50U0$libnexats.AddressType).GroupIdAddress
+                });
+                if (tokenAddress !== null) {
+                    const tokenAddressStr = tokenAddress.toString();
+                    // Extract token amount
+                    const tokenAmount = (0, $l50U0$libnexats.BNExtended).fromScriptNumBuffer(output.scriptPubKey.chunks[1].buf, false, 8).toBigInt();
+                    tokenOutputs.push({
+                        tokenId: tokenAddressStr,
+                        amount: tokenAmount.toString()
+                    });
+                }
+            }
+        }
+    } catch (error) {
+        console.warn('Failed to extract token data from transaction:', error);
+    }
+    return tokenOutputs;
+};
 class $23698d921173fdf9$export$11e896a2f3ae4119 {
     constructor(wallet, approvalCallbacks){
         this.provider = null;
@@ -3389,23 +3819,23 @@ class $23698d921173fdf9$export$11e896a2f3ae4119 {
                         // If parsing fails, keep default "Unknown" values
                         console.warn('Failed to parse transaction for approval details:', error);
                     }
+                    // Extract token outputs from transaction hex
+                    const tokenOutputs = $23698d921173fdf9$var$getTokenOutputsFromTx(request.hex, this.wallet.network);
                     const approvalDetails = {
                         dApp: this.connectedDApp,
                         account: request.account,
                         transactionHex: request.hex,
                         broadcast: request.broadcast || false,
-                        sighashSpec: request.sighashSpec,
                         totalAmount: totalAmount,
-                        fees: fees
+                        fees: fees,
+                        tokenOutputs: tokenOutputs.length > 0 ? tokenOutputs : undefined
                     };
                     const approved = await this.approvalCallbacks.approveTransaction(approvalDetails);
                     if (!approved) throw new (0, $l50U0$walletcommssdk.JsonRpcError)((0, $l50U0$walletcommssdk.JsonRpcErrorCode).RequestRejected, 'Transaction signing rejected by user');
                 }
                 // Parse and sign the transaction
                 let txBuilder = this.wallet.newTransaction(account, request.hex);
-                // Use signWithSpec if sighashSpec is provided, otherwise use regular sign
-                if (request.sighashSpec) txBuilder = txBuilder.signWithSpec(request.sighashSpec);
-                else txBuilder = txBuilder.sign();
+                txBuilder = txBuilder.sign();
                 const tx = await txBuilder.build();
                 // Broadcast if requested
                 if (request.broadcast) return await this.wallet.sendTransaction(tx); // Return just the txId string
@@ -3581,12 +4011,12 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      */ async sendTransaction(toAddress, amount, opReturnData, broadcast = true) {
         if (!this.watchOnlyWallet || !this.connectedWalletAddress) throw new Error('No wallet connected');
         // Create unsigned transaction using WatchOnlyWallet
-        let txBuilder = this.watchOnlyWallet.newTransaction().onNetwork(this.currentNetwork).sendTo(toAddress, amount);
+        let txBuilder = this.watchOnlyWallet.newTransaction().sendTo(toAddress, amount);
         // Add OP_RETURN data if provided
         if (opReturnData) txBuilder = txBuilder.addOpReturn(opReturnData);
         // Populate and build unsigned transaction
         const unsignedTx = await txBuilder.populate().build();
-        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, undefined, broadcast);
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
      * Send tokens to an address
@@ -3599,12 +4029,12 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      */ async sendTokenTransaction(toAddress, amount, tokenId, opReturnData, broadcast = true) {
         if (!this.watchOnlyWallet || !this.connectedWalletAddress) throw new Error('No wallet connected');
         // Create unsigned token transaction
-        let txBuilder = this.watchOnlyWallet.newTransaction().onNetwork(this.currentNetwork).sendToToken(toAddress, amount, tokenId);
+        let txBuilder = this.watchOnlyWallet.newTransaction().sendToToken(toAddress, amount, tokenId);
         // Add OP_RETURN data if provided
         if (opReturnData) txBuilder = txBuilder.addOpReturn(opReturnData);
         // Populate and build unsigned transaction
         const unsignedTx = await txBuilder.populate().build();
-        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, undefined, broadcast);
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
      * Create and mint a new token
@@ -3618,8 +4048,8 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      */ async createToken(name, ticker, decimals, docUrl, docHash, broadcast = true) {
         if (!this.watchOnlyWallet || !this.connectedWalletAddress) throw new Error('No wallet connected');
         // Create token creation transaction
-        const unsignedTx = await this.watchOnlyWallet.newTransaction().onNetwork(this.currentNetwork).token(name, ticker, decimals, docUrl, docHash).populate().build();
-        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, undefined, broadcast);
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().token(name, ticker, decimals, docUrl, docHash).populate().build();
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
      * Create and mint a new NFT collection
@@ -3632,8 +4062,8 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      */ async createCollection(name, ticker, docUrl, docHash, broadcast = true) {
         if (!this.watchOnlyWallet || !this.connectedWalletAddress) throw new Error('No wallet connected');
         // Create collection creation transaction
-        const unsignedTx = await this.watchOnlyWallet.newTransaction().onNetwork(this.currentNetwork).collection(name, ticker, docUrl, docHash).populate().build();
-        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, undefined, broadcast);
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().collection(name, ticker, docUrl, docHash).populate().build();
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
      * Create and mint an NFT within a collection
@@ -3645,8 +4075,8 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      */ async createNFT(parentCollection, zipUrl, zipHash, broadcast = true) {
         if (!this.watchOnlyWallet || !this.connectedWalletAddress) throw new Error('No wallet connected');
         // Create NFT creation transaction
-        const unsignedTx = await this.watchOnlyWallet.newTransaction().onNetwork(this.currentNetwork).nft(parentCollection, zipUrl, zipHash).populate().build();
-        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, undefined, broadcast);
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().nft(parentCollection, zipUrl, zipHash).populate().build();
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
      * Create and mint an SFT (Semi-Fungible Token) within a collection with specified quantity
@@ -3659,8 +4089,85 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      */ async createSFT(parentCollection, zipUrl, zipHash, quantity, broadcast = true) {
         if (!this.watchOnlyWallet || !this.connectedWalletAddress) throw new Error('No wallet connected');
         // Create SFT creation transaction
-        const unsignedTx = await this.watchOnlyWallet.newTransaction().onNetwork(this.currentNetwork).sft(parentCollection, zipUrl, zipHash, quantity).populate().build();
-        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, undefined, broadcast);
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().sft(parentCollection, zipUrl, zipHash, quantity).populate().build();
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
+    }
+    /**
+     * Sign an arbitrary unsigned transaction
+     * @param unsignedTx Unsigned transaction hex string
+     * @param sighashSpec Optional sighash specification for selective signing
+     * @param broadcast Whether to broadcast immediately (default false)
+     * @returns Promise resolving to transaction ID (if broadcast) or signed hex
+     */ async signTransaction(unsignedTx, sighashSpec, broadcast = false) {
+        if (!this.connectedWalletAddress) throw new Error('No wallet connected');
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
+    }
+    /**
+     * Build an unsigned transaction without signing
+     * @param toAddress Destination address
+     * @param amount Amount in satoshis (as string)
+     * @param tokenId Optional token ID for token transfers
+     * @param opReturnData Optional OP_RETURN data
+     * @returns Promise resolving to unsigned transaction hex
+     */ async buildTransaction(toAddress, amount, tokenId, opReturnData) {
+        if (!this.watchOnlyWallet) throw new Error('No wallet connected');
+        let txBuilder = this.watchOnlyWallet.newTransaction();
+        if (tokenId) txBuilder = txBuilder.sendToToken(toAddress, amount, tokenId);
+        else txBuilder = txBuilder.sendTo(toAddress, amount);
+        if (opReturnData) txBuilder = txBuilder.addOpReturn(opReturnData);
+        return await txBuilder.populate().build();
+    }
+    /**
+     * Build an unsigned token creation transaction
+     * @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 Promise resolving to unsigned transaction hex
+     */ async buildTokenCreation(name, ticker, decimals, docUrl, docHash) {
+        if (!this.watchOnlyWallet) throw new Error('No wallet connected');
+        return await this.watchOnlyWallet.newTransaction().token(name, ticker, decimals, docUrl, docHash).populate().build();
+    }
+    /**
+     * Build an unsigned collection creation transaction
+     * @param name Collection name
+     * @param ticker Collection ticker symbol
+     * @param docUrl URL to collection documentation
+     * @param docHash Hash of collection documentation
+     * @returns Promise resolving to unsigned transaction hex
+     */ async buildCollectionCreation(name, ticker, docUrl, docHash) {
+        if (!this.watchOnlyWallet) throw new Error('No wallet connected');
+        return await this.watchOnlyWallet.newTransaction().collection(name, ticker, docUrl, docHash).populate().build();
+    }
+    /**
+     * Build an unsigned NFT creation transaction
+     * @param parentCollection Parent collection token ID
+     * @param zipUrl URL to NFT content ZIP file
+     * @param zipHash Hash of NFT content ZIP file
+     * @returns Promise resolving to unsigned transaction hex
+     */ async buildNFTCreation(parentCollection, zipUrl, zipHash) {
+        if (!this.watchOnlyWallet) throw new Error('No wallet connected');
+        return await this.watchOnlyWallet.newTransaction().nft(parentCollection, zipUrl, zipHash).populate().build();
+    }
+    /**
+     * Build an unsigned SFT creation transaction
+     * @param parentCollection Parent collection token ID
+     * @param zipUrl URL to SFT content ZIP file
+     * @param zipHash Hash of SFT content ZIP file
+     * @param quantity Quantity of SFTs to create
+     * @returns Promise resolving to unsigned transaction hex
+     */ async buildSFTCreation(parentCollection, zipUrl, zipHash, quantity) {
+        if (!this.watchOnlyWallet) throw new Error('No wallet connected');
+        return await this.watchOnlyWallet.newTransaction().sft(parentCollection, zipUrl, zipHash, quantity).populate().build();
+    }
+    /**
+     * Initialize WatchOnlyWallet with multiple addresses
+     * @param addresses Array of addresses to watch
+     */ initializeWatchOnly(addresses) {
+        this.watchOnlyWallet = new (0, $f4ad400261a08cba$export$2e2bcd8739ae039)(addresses.map((addr)=>({
+                address: addr
+            })), this.currentNetwork);
     }
     /**
      * Create a custom unsigned transaction
@@ -3671,10 +4178,10 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      */ async createCustomTransaction(txBuilder, sighashSpec, broadcast = true) {
         if (!this.watchOnlyWallet || !this.connectedWalletAddress) throw new Error('No wallet connected');
         // Create custom transaction using provided builder function
-        const builder = this.watchOnlyWallet.newTransaction().onNetwork(this.currentNetwork);
+        const builder = this.watchOnlyWallet.newTransaction();
         const configuredBuilder = txBuilder(builder);
         const unsignedTx = await configuredBuilder.populate().build();
-        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, sighashSpec, broadcast);
+        return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
      * Sign a message with the connected wallet