nexa-wallet-sdk 0.5.0 → 0.5.2

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.5.0\",\"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}}");
+$2dd241e44b9dc3c2$exports = JSON.parse("{\"name\":\"nexa-wallet-sdk\",\"version\":\"0.5.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.1\"},\"files\":[\"dist\"],\"directories\":{\"test\":\"tests\"},\"@parcel/resolver-default\":{\"packageExports\":true}}");
 
 
 
@@ -375,6 +375,7 @@ class $f8a48da5c0b6346a$export$c54c8796e94a37a0 {
     }
     constructor(_bip44Account){
         this._tokenBalances = {};
+        this._tokenAuthorities = {};
         this._transactions = new Map();
         this._bip44Account = _bip44Account;
         this._balance = {
@@ -382,6 +383,7 @@ class $f8a48da5c0b6346a$export$c54c8796e94a37a0 {
             unconfirmed: 0
         };
         this._tokenBalances = {};
+        this._tokenAuthorities = {};
     }
     get balance() {
         return this._balance;
@@ -395,6 +397,12 @@ class $f8a48da5c0b6346a$export$c54c8796e94a37a0 {
     set tokenBalances(value) {
         this._tokenBalances = value;
     }
+    get tokenAuthorities() {
+        return this._tokenAuthorities;
+    }
+    set tokenAuthorities(value) {
+        this._tokenAuthorities = value;
+    }
     async fetchAndClassifyTransactions(transactionAddress, fromHeight) {
         const transactions = await (0, $0d59d2bcffd646c5$export$a2ed4b531376a5a4)([
             transactionAddress
@@ -444,7 +452,7 @@ class $cf960f437fe63027$export$2e2bcd8739ae039 extends (0, $f8a48da5c0b6346a$exp
         };
     }
     async loadBalances() {
-        let balances = await (0, $0d59d2bcffd646c5$export$9e38d26dbd7c33f4)([
+        const { balances: balances, authorities: authorities } = await (0, $0d59d2bcffd646c5$export$e4fb0bc90aacba9e)([
             this._accountKey
         ]);
         let tokenBalances = [
@@ -452,6 +460,7 @@ class $cf960f437fe63027$export$2e2bcd8739ae039 extends (0, $f8a48da5c0b6346a$exp
         ].map((k)=>k.tokensBalance);
         super.balance = (0, $0d59d2bcffd646c5$export$a26005fb5b8d1e4a)(balances);
         super.tokenBalances = (0, $0d59d2bcffd646c5$export$dec515296f176dbe)(tokenBalances);
+        super.tokenAuthorities = authorities;
     }
     getKeyFromAddress(address) {
         if (address !== this._accountKey.address) throw new Error(`Address ${address} does not belong to this account`);
@@ -505,10 +514,11 @@ class $1c49a4fffc97409b$export$2e2bcd8739ae039 extends (0, $f8a48da5c0b6346a$exp
         return this._accountKeys;
     }
     async loadBalances() {
-        let balances = await (0, $0d59d2bcffd646c5$export$9e38d26dbd7c33f4)(this._accountKeys.receiveKeys.concat(this._accountKeys.changeKeys));
+        const { balances: balances, authorities: authorities } = await (0, $0d59d2bcffd646c5$export$e4fb0bc90aacba9e)(this._accountKeys.receiveKeys.concat(this._accountKeys.changeKeys));
         let tokenBalances = this._accountKeys.receiveKeys.concat(this._accountKeys.changeKeys).map((k)=>k.tokensBalance);
         super.balance = (0, $0d59d2bcffd646c5$export$a26005fb5b8d1e4a)(balances);
         super.tokenBalances = (0, $0d59d2bcffd646c5$export$dec515296f176dbe)(tokenBalances);
+        super.tokenAuthorities = authorities;
     }
     getKeyFromAddress(address) {
         const allKeys = this._accountKeys.receiveKeys.concat(this._accountKeys.changeKeys);
@@ -595,7 +605,7 @@ class $0b557605c0e99621$export$2e2bcd8739ae039 extends (0, $f8a48da5c0b6346a$exp
         };
     }
     async loadBalances() {
-        let balances = await (0, $0d59d2bcffd646c5$export$9e38d26dbd7c33f4)([
+        const { balances: balances, authorities: authorities } = await (0, $0d59d2bcffd646c5$export$e4fb0bc90aacba9e)([
             this._accountKey
         ]);
         let tokenBalances = [
@@ -603,6 +613,7 @@ class $0b557605c0e99621$export$2e2bcd8739ae039 extends (0, $f8a48da5c0b6346a$exp
         ].map((k)=>k.tokensBalance);
         super.balance = (0, $0d59d2bcffd646c5$export$a26005fb5b8d1e4a)(balances);
         super.tokenBalances = (0, $0d59d2bcffd646c5$export$dec515296f176dbe)(tokenBalances);
+        super.tokenAuthorities = authorities;
     }
     getKeyFromAddress(address) {
         if (address !== this._accountKey.address) throw new Error(`Address ${address} does not belong to this account`);
@@ -658,6 +669,70 @@ function $bc5ca2c06b1affa3$export$f12d707d2b261fb6(txIdem, outputIndex) {
 }
 
 
+
+function $22e282633cad8f97$export$7f7cffd29bf2d96d(authFlags, permission) {
+    if (authFlags > 0) return false;
+    let flags = BigInt.asUintN(64, BigInt(authFlags));
+    switch(permission){
+        case 'authorise':
+            return (0, $l50U0$libnexats.GroupToken).allowsRenew(flags);
+        case 'mint':
+            return (0, $l50U0$libnexats.GroupToken).allowsMint(flags);
+        case 'melt':
+            return (0, $l50U0$libnexats.GroupToken).allowsMelt(flags);
+        case 'rescript':
+            return (0, $l50U0$libnexats.GroupToken).allowsRescript(flags);
+        case 'subgroup':
+            return (0, $l50U0$libnexats.GroupToken).allowsSubgroup(flags);
+        default:
+            return false;
+    }
+}
+function $22e282633cad8f97$export$636fb0b03b94ac81(authFlags, withSubgroup = true) {
+    if (authFlags > 0) return 0n;
+    let flags = BigInt.asUintN(64, BigInt(authFlags));
+    let newFlags = (0, $l50U0$libnexats.GroupToken).authFlags.AUTHORITY;
+    if ((0, $l50U0$libnexats.GroupToken).allowsRenew(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.BATON;
+    if ((0, $l50U0$libnexats.GroupToken).allowsMint(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MINT;
+    if ((0, $l50U0$libnexats.GroupToken).allowsMelt(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MELT;
+    if ((0, $l50U0$libnexats.GroupToken).allowsRescript(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.RESCRIPT;
+    if ((0, $l50U0$libnexats.GroupToken).allowsSubgroup(flags) && withSubgroup) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.SUBGROUP;
+    return newFlags;
+}
+function $22e282633cad8f97$export$e240c810a53c3a0c(perms) {
+    let newFlags = (0, $l50U0$libnexats.GroupToken).authFlags.AUTHORITY;
+    for (let perm of perms)switch(perm){
+        case 'authorise':
+            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.BATON;
+            break;
+        case 'mint':
+            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MINT;
+            break;
+        case 'melt':
+            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MELT;
+            break;
+        case 'rescript':
+            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.RESCRIPT;
+            break;
+        case 'subgroup':
+            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.SUBGROUP;
+            break;
+    }
+    return newFlags;
+}
+function $22e282633cad8f97$export$c949c84578b9e236(authFlags) {
+    if (authFlags > 0) return [];
+    const permissions = [];
+    const flags = BigInt.asUintN(64, BigInt(authFlags));
+    if ((0, $l50U0$libnexats.GroupToken).allowsRenew(flags)) permissions.push('authorise');
+    if ((0, $l50U0$libnexats.GroupToken).allowsMint(flags)) permissions.push('mint');
+    if ((0, $l50U0$libnexats.GroupToken).allowsMelt(flags)) permissions.push('melt');
+    if ((0, $l50U0$libnexats.GroupToken).allowsRescript(flags)) permissions.push('rescript');
+    if ((0, $l50U0$libnexats.GroupToken).allowsSubgroup(flags)) permissions.push('subgroup');
+    return permissions;
+}
+
+
 var $0d59d2bcffd646c5$export$dcc1fb6ad5308e56 = /*#__PURE__*/ function(TxTokenType) {
     TxTokenType[TxTokenType["NO_GROUP"] = 0] = "NO_GROUP";
     TxTokenType[TxTokenType["CREATE"] = 1] = "CREATE";
@@ -860,35 +935,81 @@ async function $0d59d2bcffd646c5$var$isAddressUsed(address) {
         throw e;
     }
 }
-async function $0d59d2bcffd646c5$var$getKeyTokenBalance(key) {
-    let tokensBalance = await (0, $b5bfd17fdf06d231$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()
+async function $0d59d2bcffd646c5$var$getKeyTokenBalanceAndAuthorities(address) {
+    const tokensBalance = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokensBalance(address);
+    const balance = {};
+    const authorities = {};
+    // Get all unique token IDs from both confirmed and unconfirmed
+    const allTokenIds = new Set([
+        ...Object.keys(tokensBalance.confirmed),
+        ...Object.keys(tokensBalance.unconfirmed)
+    ]);
+    // Process each token to get both balance and check for authorities
+    for (const tokenId of allTokenIds){
+        const confirmedAmount = tokensBalance.confirmed[tokenId] || 0;
+        const unconfirmedAmount = tokensBalance.unconfirmed[tokenId] || 0;
+        // Add to balance if non-zero
+        if (confirmedAmount !== 0 || unconfirmedAmount !== 0) balance[tokenId] = {
+            confirmed: BigInt(confirmedAmount).toString(),
+            unconfirmed: BigInt(unconfirmedAmount).toString()
         };
+        // Check for authorities by getting token UTXOs
+        try {
+            const tokenUtxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(address, tokenId);
+            if (tokenUtxos && tokenUtxos.length > 0) {
+                // Look for authorities (negative amounts)
+                const authUtxos = tokenUtxos.filter((utxo)=>{
+                    const amount = parseInt(String(utxo.token_amount || '0'));
+                    return amount < 0;
+                });
+                // Add permissions and address to each authority UTXO and organize by token ID
+                if (authUtxos.length > 0) {
+                    const authoritiesWithPermissions = authUtxos.map((utxo)=>({
+                            ...utxo,
+                            permissions: (0, $22e282633cad8f97$export$c949c84578b9e236)(parseInt(String(utxo.token_amount || '0'))),
+                            address: address
+                        }));
+                    authorities[tokenId] = authoritiesWithPermissions;
+                }
+            }
+        } catch (error) {
+            console.warn(`Error checking authorities for token ${tokenId} on address ${address}:`, error);
+        }
     }
-    return balance;
+    return {
+        balance: balance,
+        authorities: authorities
+    };
 }
 async function $0d59d2bcffd646c5$var$getAndUpdateAddressKeyBalance(key) {
     let balance = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getBalance(key.address);
     key.balance = (BigInt(balance.confirmed) + BigInt(balance.unconfirmed)).toString();
-    key.tokensBalance = await $0d59d2bcffd646c5$var$getKeyTokenBalance(key);
-    return balance;
+    const { balance: tokenBalance, authorities: authorities } = await $0d59d2bcffd646c5$var$getKeyTokenBalanceAndAuthorities(key.address);
+    key.tokensBalance = tokenBalance;
+    return {
+        balance: balance,
+        authorities: authorities
+    };
 }
-async function $0d59d2bcffd646c5$export$9e38d26dbd7c33f4(keys) {
+async function $0d59d2bcffd646c5$export$e4fb0bc90aacba9e(keys) {
     let promises = [];
     keys.forEach((key)=>{
-        let b = $0d59d2bcffd646c5$var$getAndUpdateAddressKeyBalance(key);
-        promises.push(b);
+        promises.push($0d59d2bcffd646c5$var$getAndUpdateAddressKeyBalance(key));
+    });
+    const results = await Promise.all(promises);
+    const balances = results.map((r)=>r.balance);
+    // Combine authorities from all addresses, merging by token ID
+    const combinedAuthorities = {};
+    results.forEach((result)=>{
+        Object.keys(result.authorities).forEach((tokenId)=>{
+            if (combinedAuthorities[tokenId]) combinedAuthorities[tokenId] = combinedAuthorities[tokenId].concat(result.authorities[tokenId]);
+            else combinedAuthorities[tokenId] = result.authorities[tokenId];
+        });
     });
-    return await Promise.all(promises);
+    return {
+        balances: balances,
+        authorities: combinedAuthorities
+    };
 }
 function $0d59d2bcffd646c5$export$a26005fb5b8d1e4a(balances) {
     let confirmed = new (0, ($parcel$interopDefault($l50U0$jsbigdecimal)))(0), unconfirmed = new (0, ($parcel$interopDefault($l50U0$jsbigdecimal)))(0);
@@ -1296,7 +1417,6 @@ var $90290c84737dbb50$export$2e2bcd8739ae039 = $90290c84737dbb50$var$isString;
 
 
 
-
 class $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6 {
     static getAllKeys(keys) {
         return keys.receiveKeys.concat(keys.changeKeys);
@@ -1310,60 +1430,8 @@ class $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6 {
 
 
 
-function $22e282633cad8f97$export$7f7cffd29bf2d96d(authFlags, permission) {
-    if (authFlags > 0) return false;
-    let flags = BigInt.asUintN(64, BigInt(authFlags));
-    switch(permission){
-        case 'authorise':
-            return (0, $l50U0$libnexats.GroupToken).allowsRenew(flags);
-        case 'mint':
-            return (0, $l50U0$libnexats.GroupToken).allowsMint(flags);
-        case 'melt':
-            return (0, $l50U0$libnexats.GroupToken).allowsMelt(flags);
-        case 'rescript':
-            return (0, $l50U0$libnexats.GroupToken).allowsRescript(flags);
-        case 'subgroup':
-            return (0, $l50U0$libnexats.GroupToken).allowsSubgroup(flags);
-        default:
-            return false;
-    }
-}
-function $22e282633cad8f97$export$636fb0b03b94ac81(authFlags, withSubgroup = true) {
-    if (authFlags > 0) return 0n;
-    let flags = BigInt.asUintN(64, BigInt(authFlags));
-    let newFlags = (0, $l50U0$libnexats.GroupToken).authFlags.AUTHORITY;
-    if ((0, $l50U0$libnexats.GroupToken).allowsRenew(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.BATON;
-    if ((0, $l50U0$libnexats.GroupToken).allowsMint(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MINT;
-    if ((0, $l50U0$libnexats.GroupToken).allowsMelt(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MELT;
-    if ((0, $l50U0$libnexats.GroupToken).allowsRescript(flags)) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.RESCRIPT;
-    if ((0, $l50U0$libnexats.GroupToken).allowsSubgroup(flags) && withSubgroup) newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.SUBGROUP;
-    return newFlags;
-}
-function $22e282633cad8f97$export$e240c810a53c3a0c(perms) {
-    let newFlags = (0, $l50U0$libnexats.GroupToken).authFlags.AUTHORITY;
-    for (let perm of perms)switch(perm){
-        case 'authorise':
-            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.BATON;
-            break;
-        case 'mint':
-            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MINT;
-            break;
-        case 'melt':
-            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.MELT;
-            break;
-        case 'rescript':
-            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.RESCRIPT;
-            break;
-        case 'subgroup':
-            newFlags |= (0, $l50U0$libnexats.GroupToken).authFlags.SUBGROUP;
-            break;
-    }
-    return newFlags;
-}
-
-
 /** 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);
@@ -1373,6 +1441,7 @@ 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){
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             let input = {
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
@@ -1380,6 +1449,7 @@ async function $b4a043612f1c4089$export$afd979971a55acfc(txBuilder, keys, totalT
                 templateData: options.templateData
             };
             txBuilder.from(input);
+            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);
@@ -1423,11 +1493,8 @@ async function $b4a043612f1c4089$export$afd979971a55acfc(txBuilder, keys, totalT
     };
     throw new Error(JSON.stringify(err));
 }
-async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token, outTokenAmount) {
-    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));
-    let allKeys = rKeys.concat(cKeys);
+async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token, outTokenAmount, spentOutpoints) {
+    let allKeys = keys.receiveKeys.concat(keys.changeKeys);
     if ((0, $bc5ca2c06b1affa3$export$c8733ae29fb53302)(allKeys)) throw new Error("Not enough token balance.");
     let usedKeys = new Map();
     let inTokenAmount = 0n;
@@ -1435,6 +1502,7 @@ 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;
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
@@ -1442,13 +1510,13 @@ async function $b4a043612f1c4089$export$931e37acdaa22dcf(txBuilder, keys, token,
                 groupId: utxo.group,
                 groupAmount: BigInt(utxo.token_amount)
             });
+            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");
             if (txBuilder.transaction.inputs.length > $b4a043612f1c4089$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
                 const tokenChangeAddress = keys.changeKeys.length > 0 ? keys.changeKeys[keys.changeKeys.length - 1].address : keys.receiveKeys[keys.receiveKeys.length - 1].address;
                 txBuilder.to(tokenChangeAddress, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, inTokenAmount - outTokenAmount);
                 return Array.from(usedKeys.values());
@@ -1457,7 +1525,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 = '';
@@ -1466,11 +1534,13 @@ 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){
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
                 satoshis: utxo.value
             });
+            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);
@@ -1499,17 +1569,19 @@ 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;
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
             txBuilder.from({
                 outpoint: utxo.outpoint_hash,
                 address: key.address,
                 satoshis: utxo.value
             });
+            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);
@@ -1526,7 +1598,109 @@ 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$fc6e64edb1452fc7(txBuilder, keys, token, amount, parentToken, spentOutpoints) {
+    const privateKeys = [];
+    const allKeys = (0, $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6).getAllKeys(keys);
+    // Determine which token to look for authority
+    const authTokenId = parentToken || token;
+    const isSubgroupMint = !!parentToken;
+    // Find and add mint authority
+    let mintAuthorityFound = false;
+    for (let key of allKeys){
+        if (mintAuthorityFound) break;
+        let authUtxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(key.address, authTokenId);
+        for (let utxo of authUtxos){
+            if (!(0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, 'mint')) continue;
+            // Skip if already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
+            // Add mint authority as input
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value
+            });
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
+            // Create the minted tokens output
+            const mintAddress = keys.receiveKeys[keys.receiveKeys.length - 1].address;
+            txBuilder.to(mintAddress, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, amount);
+            // Preserve the mint authority for future use
+            if ((0, $l50U0$libnexats.GroupToken).allowsRenew(BigInt.asUintN(64, BigInt(utxo.token_amount)))) {
+                const authChangeAddress = keys.changeKeys.length > 0 ? keys.changeKeys[keys.changeKeys.length - 1].address : keys.receiveKeys[keys.receiveKeys.length - 1].address;
+                txBuilder.to(authChangeAddress, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, authTokenId, (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount));
+            }
+            privateKeys.push(key.key.privateKey);
+            mintAuthorityFound = true;
+            break;
+        }
+    }
+    if (!mintAuthorityFound) throw new Error(`Mint authority not found for token ${authTokenId}`);
+    return privateKeys;
+}
+async function $b4a043612f1c4089$export$661377a8795b235c(txBuilder, keys, token, amount, parentToken, spentOutpoints) {
+    const privateKeys = [];
+    const allKeys = (0, $4d68f29c39c1a3e4$export$94f569bf4eb0f6f6).getAllKeys(keys);
+    const authTokenId = parentToken || token;
+    // First, find and add melt authority
+    let meltAuthorityFound = false;
+    for (let key of allKeys){
+        if (meltAuthorityFound) break;
+        let authUtxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(key.address, authTokenId);
+        for (let utxo of authUtxos){
+            if (!(0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, 'melt')) continue;
+            // Skip if already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
+            // Add melt authority as input
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value
+            });
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
+            // Preserve the melt authority for future use
+            if ((0, $l50U0$libnexats.GroupToken).allowsRenew(BigInt.asUintN(64, BigInt(utxo.token_amount)))) {
+                const authChangeAddress = keys.changeKeys.length > 0 ? keys.changeKeys[keys.changeKeys.length - 1].address : keys.receiveKeys[keys.receiveKeys.length - 1].address;
+                txBuilder.to(authChangeAddress, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount));
+            }
+            privateKeys.push(key.key.privateKey);
+            meltAuthorityFound = true;
+            break;
+        }
+    }
+    if (!meltAuthorityFound) throw new Error("Melt authority not found for token");
+    // Now find and add token UTXOs to melt
+    let inTokenAmount = 0n;
+    for (let key of allKeys){
+        let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(key.address, token);
+        for (let utxo of utxos){
+            // Skip authorities (negative amounts)
+            if (utxo.token_amount < 0) continue;
+            // Skip if already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
+            // Add token UTXO as input
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: key.address,
+                satoshis: utxo.value,
+                groupId: utxo.group,
+                groupAmount: BigInt(utxo.token_amount)
+            });
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
+            inTokenAmount += BigInt(utxo.token_amount);
+            if (!privateKeys.includes(key.key.privateKey)) privateKeys.push(key.key.privateKey);
+            // Check if we have enough tokens to melt
+            if (inTokenAmount >= amount) {
+                // Create change output if melting less than full amount
+                if (inTokenAmount > amount) {
+                    const changeAddress = keys.changeKeys.length > 0 ? keys.changeKeys[keys.changeKeys.length - 1].address : keys.receiveKeys[keys.receiveKeys.length - 1].address;
+                    txBuilder.to(changeAddress, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, inTokenAmount - amount);
+                }
+                return privateKeys;
+            }
+        }
+    }
+    throw new Error(`Not enough token balance to melt. Required: ${amount}, Available: ${inTokenAmount}`);
+}
+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);
@@ -1535,6 +1709,7 @@ 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;
+            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);
@@ -1547,6 +1722,7 @@ async function $b4a043612f1c4089$export$28a843ca046a6b3f(txBuilder, keys, token,
                 satoshis: utxo.value
             });
             usedKeys.push(key.key.privateKey);
+            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));
@@ -1555,6 +1731,34 @@ async function $b4a043612f1c4089$export$28a843ca046a6b3f(txBuilder, keys, token,
     }
     throw new Error("The required authorities not found");
 }
+function $b4a043612f1c4089$export$eabd1dee7adcf71(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;
+}
 
 
 
@@ -1695,6 +1899,7 @@ 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)();
@@ -1812,15 +2017,27 @@ 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
      * @param amount Amount to send
      * @param token Token ID
      * @param action Action type (mint, melt, send, etc.)
+     * @param parent Optional parent token ID (for NFT/SFT minting)
      * @throws Error if validation fails
-     */ tokenAction(toAddr, amount, token, action) {
-        // Validate destination address
+     */ tokenAction(toAddr, amount, token, action, parent) {
+        // Validate destokenActiontination 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 (token && BigInt(amount) < 1n || !token && (0, $ed110f8656071ee4$export$2e2bcd8739ae039)(amount) < (0, $l50U0$libnexats.Transaction).DUST_AMOUNT) throw new Error("The amount is too low.");
@@ -1829,11 +2046,13 @@ class $57b0117fe8233fef$export$bba690fb5c12ba04 {
         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
+        // For mint and melt operations, don't add output here - specialized functions will handle it
+        if (action !== 'mint' && action !== 'melt') // Add output to transaction for regular token operations (send, etc.)
         this.transactionBuilder.to(toAddr, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, BigInt(amount));
         // Record the token action
         this.tokens.add({
             token: token,
+            parentToken: parent,
             amount: BigInt(amount),
             action: action
         });
@@ -2157,17 +2376,17 @@ class $e1896e59040fa3c5$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
         if (this._keysToSign.length == 0) this._keysToSign.push(this._account.getPrimaryAddressKey().key.privateKey);
         return this;
     }
-    mint(token, amount) {
+    mint(token, amount, parent) {
         this.builder.push(async ()=>{
             let toAddr = this._account.accountKeys.receiveKeys.at(-1).address;
-            this.tokenAction(toAddr, amount, token, 'mint');
+            this.tokenAction(toAddr, amount, token, 'mint', parent);
         });
         return this;
     }
-    melt(token, amount) {
+    melt(token, amount, parent) {
         this.builder.push(async ()=>{
             let toAddr = this._account.accountKeys.receiveKeys.at(-1).address;
-            this.tokenAction(toAddr, amount, token, 'melt');
+            this.tokenAction(toAddr, amount, token, 'melt', parent);
         });
         return this;
     }
@@ -2177,23 +2396,22 @@ 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') tK = tK.concat(await (0, $b4a043612f1c4089$export$fc6e64edb1452fc7)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.amount, tokenAction.parentToken, this.spentOutpoints));
+                else if (tokenAction.action == 'melt') tK = tK.concat(await (0, $b4a043612f1c4089$export$661377a8795b235c)(this.transactionBuilder, this._account.accountKeys, tokenAction.token, tokenAction.amount, tokenAction.parentToken, 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);
             // Process each transaction input using placeholder-based signing
             const inputs = this.transactionBuilder.transaction.inputs;
             for(let inputIndex = 0; inputIndex < inputs.length; inputIndex++){
@@ -2350,7 +2568,7 @@ class $e1896e59040fa3c5$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
         // Empty scriptSig - sign with SIGHASH_ALL
         if (chunks.length === 0) return {
             strategy: 'sign_all',
-            sighashType: null
+            sighashType: (0, $l50U0$libnexats.SighashType).ALL
         };
         // Single chunk
         if (chunks.length === 1) {
@@ -2383,11 +2601,7 @@ class $e1896e59040fa3c5$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
                     placeholderIndex = i;
                     sighashType = this.extractSighashFromPlaceholder(chunk.buf);
                 } else // Non-placeholder satisfier element - preserve it
-                satisfierElements.push({
-                    buf: chunk.buf,
-                    len: chunk.len || (chunk.buf ? chunk.buf.length : 0),
-                    opcodenum: chunk.opcodenum
-                });
+                satisfierElements.push(chunk);
             }
             if (placeholderIndex !== undefined) return {
                 strategy: 'replace_placeholder',
@@ -2462,10 +2676,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));
@@ -2576,6 +2794,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;
+    }
 }
 
 
@@ -2667,6 +2920,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)) {
@@ -2820,7 +3074,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
@@ -3038,6 +3292,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;
+    }
 }
 
 
@@ -3049,13 +3344,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,
@@ -3063,6 +3360,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
@@ -3106,7 +3405,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;
@@ -3114,6 +3413,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,
@@ -3121,6 +3422,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");
@@ -3135,17 +3438,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);
@@ -3172,19 +3479,23 @@ 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 = '', subgroupAddr = '', 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);
+                txBuilder.to(subgroupAddr, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, subgroup, subgroupQuantity);
             }
             // if renew flag included, we don't want to burn it
             if ((0, $l50U0$libnexats.GroupToken).allowsRenew(BigInt.asUintN(64, BigInt(utxo.token_amount)))) txBuilder.to(item.address, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount));
@@ -3195,7 +3506,95 @@ 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$91f9f23df90683cc(txBuilder, addresses, token, amount, parentToken, spentOutpoints) {
+    const usedAddresses = [];
+    // Determine which token to look for authority
+    const authTokenId = parentToken || token;
+    // Find and add mint authority
+    let mintAuthorityFound = false;
+    for (let item of addresses){
+        if (mintAuthorityFound) break;
+        let authUtxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(item.address, authTokenId);
+        for (let utxo of authUtxos){
+            if (!(0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, 'mint')) continue;
+            // Skip if already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
+            // Add mint authority as input
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value
+            });
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
+            // Create the minted tokens output
+            txBuilder.to(item.address, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, amount);
+            // Preserve the mint authority for future use if renewable
+            if ((0, $l50U0$libnexats.GroupToken).allowsRenew(BigInt.asUintN(64, BigInt(utxo.token_amount)))) txBuilder.to(item.address, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, authTokenId, (0, $22e282633cad8f97$export$636fb0b03b94ac81)(utxo.token_amount));
+            usedAddresses.push(item.address);
+            mintAuthorityFound = true;
+            break;
+        }
+    }
+    if (!mintAuthorityFound) throw new Error(`Mint authority not found for token ${authTokenId}`);
+    return usedAddresses;
+}
+async function $52632971edbdb934$export$cfda880a425a2203(txBuilder, addresses, token, amount, parentToken, spentOutpoints) {
+    const usedAddresses = [];
+    // Determine which token to look for melt authority
+    const authTokenId = parentToken || token;
+    // Find and add melt authority first
+    let meltAuthorityFound = false;
+    for (let item of addresses){
+        if (meltAuthorityFound) break;
+        let authUtxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(item.address, authTokenId);
+        for (let utxo of authUtxos){
+            if (!(0, $22e282633cad8f97$export$7f7cffd29bf2d96d)(utxo.token_amount, 'melt')) continue;
+            // Skip if already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
+            // Add melt authority as input
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value
+            });
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
+            usedAddresses.push(item.address);
+            meltAuthorityFound = true;
+            break;
+        }
+    }
+    if (!meltAuthorityFound) throw new Error("Melt authority not found for token");
+    // Now find and add token UTXOs to melt
+    let inTokenAmount = 0n;
+    for (let item of addresses){
+        let utxos = await (0, $b5bfd17fdf06d231$export$eaa49f0478d81b9d).getTokenUtxos(item.address, token);
+        for (let utxo of utxos){
+            // Skip authorities (negative amounts)
+            if (utxo.token_amount < 0) continue;
+            // Skip if already spent
+            if (spentOutpoints && spentOutpoints.has(utxo.outpoint_hash)) continue;
+            // Add token UTXO as input
+            txBuilder.from({
+                outpoint: utxo.outpoint_hash,
+                address: item.address,
+                satoshis: utxo.value,
+                groupId: utxo.group,
+                groupAmount: BigInt(utxo.token_amount)
+            });
+            if (spentOutpoints) spentOutpoints.add(utxo.outpoint_hash);
+            inTokenAmount += BigInt(utxo.token_amount);
+            if (!usedAddresses.includes(item.address)) usedAddresses.push(item.address);
+            // Check if we have enough tokens to melt
+            if (inTokenAmount >= amount) {
+                // Create change output if melting less than full amount
+                if (inTokenAmount > amount) txBuilder.to(item.address, (0, $l50U0$libnexats.Transaction).DUST_AMOUNT, token, inTokenAmount - amount);
+                return usedAddresses;
+            }
+        }
+    }
+    throw new Error(`Not enough token balance to melt. Required: ${amount}, Available: ${inTokenAmount}`);
+}
+async function $52632971edbdb934$export$5c44e04d8c04c292(txBuilder, addresses, token, perms, toAddr, spentOutpoints) {
     let usedAddresses = [];
     let reqiredPerms = new Set(perms);
     reqiredPerms.add('authorise');
@@ -3203,6 +3602,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);
@@ -3215,6 +3616,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;
@@ -3264,10 +3667,11 @@ class $2ce5b75d10954bb1$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
      * @param token Token ID to mint
      * @param amount Amount to mint
      * @param toAddr Destination address for minted tokens
+     * @param parent Optional parent token ID (for NFT/SFT minting)
      * @returns This instance for chaining
-     */ mint(token, amount, toAddr) {
+     */ mint(token, amount, toAddr, parent) {
         this.builder.push(async ()=>{
-            this.tokenAction(toAddr, amount, token, 'mint');
+            this.tokenAction(toAddr, amount, token, 'mint', parent);
         });
         return this;
     }
@@ -3276,10 +3680,11 @@ class $2ce5b75d10954bb1$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
      * @param token Token ID to melt
      * @param amount Amount to melt
      * @param toAddr Destination address for melted tokens
+     * @param parent Optional parent token ID (for NFT/SFT melting)
      * @returns This instance for chaining
-     */ melt(token, amount, toAddr) {
+     */ melt(token, amount, toAddr, parent) {
         this.builder.push(async ()=>{
-            this.tokenAction(toAddr, amount, token, 'melt');
+            this.tokenAction(toAddr, amount, token, 'melt', parent);
         });
         return this;
     }
@@ -3294,23 +3699,25 @@ class $2ce5b75d10954bb1$export$2e2bcd8739ae039 extends (0, $57b0117fe8233fef$exp
             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, $52632971edbdb934$export$d7c9c386067a6463)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.action));
+                if (tokenAction.action == 'mint') // Use specialized mint function for groups and subgroups
+                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$91f9f23df90683cc)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.amount, tokenAction.parentToken, this.spentOutpoints));
+                else if (tokenAction.action == 'melt') // Use specialized melt function for groups and subgroups
+                tokenAddresses = tokenAddresses.concat(await (0, $52632971edbdb934$export$cfda880a425a2203)(this.transactionBuilder, this._availableAddresses, tokenAction.token, tokenAction.amount, tokenAction.parentToken, 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, this._availableAddresses[0]?.address, 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);
         });
@@ -3885,7 +4292,7 @@ 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
@@ -3903,7 +4310,7 @@ 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
@@ -3922,7 +4329,7 @@ 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();
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().token(name, ticker, decimals, docUrl, docHash).populate().build();
         return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
@@ -3936,7 +4343,7 @@ 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();
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().collection(name, ticker, docUrl, docHash).populate().build();
         return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
@@ -3949,7 +4356,7 @@ 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();
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().nft(parentCollection, zipUrl, zipHash).populate().build();
         return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
@@ -3963,7 +4370,7 @@ 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();
+        const unsignedTx = await this.watchOnlyWallet.newTransaction().sft(parentCollection, zipUrl, zipHash, quantity).populate().build();
         return await this.provider.signTransaction(this.connectedWalletAddress, unsignedTx, broadcast);
     }
     /**
@@ -3985,7 +4392,7 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      * @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().onNetwork(this.currentNetwork);
+        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);
@@ -4001,7 +4408,7 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      * @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().onNetwork(this.currentNetwork).token(name, ticker, decimals, docUrl, docHash).populate().build();
+        return await this.watchOnlyWallet.newTransaction().token(name, ticker, decimals, docUrl, docHash).populate().build();
     }
     /**
      * Build an unsigned collection creation transaction
@@ -4012,7 +4419,7 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      * @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().onNetwork(this.currentNetwork).collection(name, ticker, docUrl, docHash).populate().build();
+        return await this.watchOnlyWallet.newTransaction().collection(name, ticker, docUrl, docHash).populate().build();
     }
     /**
      * Build an unsigned NFT creation transaction
@@ -4022,7 +4429,7 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      * @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().onNetwork(this.currentNetwork).nft(parentCollection, zipUrl, zipHash).populate().build();
+        return await this.watchOnlyWallet.newTransaction().nft(parentCollection, zipUrl, zipHash).populate().build();
     }
     /**
      * Build an unsigned SFT creation transaction
@@ -4033,7 +4440,7 @@ class $4d217697e55d958e$export$80793d8292a1630a {
      * @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().onNetwork(this.currentNetwork).sft(parentCollection, zipUrl, zipHash, quantity).populate().build();
+        return await this.watchOnlyWallet.newTransaction().sft(parentCollection, zipUrl, zipHash, quantity).populate().build();
     }
     /**
      * Initialize WatchOnlyWallet with multiple addresses
@@ -4052,7 +4459,7 @@ 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, broadcast);