nexa-wallet-sdk 0.1.2

package/src/utils/TokenUtils.ts

@@ -0,0 +1,75 @@
+import {PermissionLabel} from "../models/transaction.entities";
+import {GroupToken} from "libnexa-ts";
+
+export function isAuthFit(authFlags: bigint | number, permission: PermissionLabel): boolean {
+    if (authFlags > 0) {
+        return false;
+    }
+
+    let flags = BigInt.asUintN(64, BigInt(authFlags));
+    switch (permission) {
+        case 'authorise':
+            return GroupToken.allowsRenew(flags);
+        case 'mint':
+            return GroupToken.allowsMint(flags);
+        case 'melt':
+            return GroupToken.allowsMelt(flags);
+        case 'rescript':
+            return GroupToken.allowsRescript(flags);
+        case 'subgroup':
+            return GroupToken.allowsSubgroup(flags);
+        default:
+            return false;
+    }
+}
+
+export function dupAuthority(authFlags: bigint | number, withSubgroup = true): bigint {
+    if (authFlags > 0) {
+        return 0n;
+    }
+
+    let flags = BigInt.asUintN(64, BigInt(authFlags));
+    let newFlags = GroupToken.authFlags.AUTHORITY;
+
+    if (GroupToken.allowsRenew(flags)) {
+        newFlags |= GroupToken.authFlags.BATON;
+    }
+    if (GroupToken.allowsMint(flags)) {
+        newFlags |= GroupToken.authFlags.MINT;
+    }
+    if (GroupToken.allowsMelt(flags)) {
+        newFlags |= GroupToken.authFlags.MELT;
+    }
+    if (GroupToken.allowsRescript(flags)) {
+        newFlags |= GroupToken.authFlags.RESCRIPT;
+    }
+    if (GroupToken.allowsSubgroup(flags) && withSubgroup) {
+        newFlags |= GroupToken.authFlags.SUBGROUP;
+    }
+
+    return newFlags;
+}
+
+export function buildAuthority(perms: PermissionLabel[]): bigint {
+    let newFlags = GroupToken.authFlags.AUTHORITY;
+    for (let perm of perms) {
+        switch (perm) {
+            case 'authorise':
+                newFlags |= GroupToken.authFlags.BATON;
+                break;
+            case 'mint':
+                newFlags |= GroupToken.authFlags.MINT;
+                break;
+            case 'melt':
+                newFlags |= GroupToken.authFlags.MELT;
+                break;
+            case 'rescript':
+                newFlags |= GroupToken.authFlags.RESCRIPT;
+                break;
+            case 'subgroup':
+                newFlags |= GroupToken.authFlags.SUBGROUP;
+                break;
+        }
+    }
+    return newFlags;
+}

package/src/utils/ValidationUtils.ts

@@ -0,0 +1,86 @@
+import { isString } from 'lodash-es';
+
+/** Type definition for constructor functions */
+type Class<T> = new (...args: any[]) => T; // eslint-disable-line @typescript-eslint/no-explicit-any
+
+/**
+ * Utility class for validating arguments and state conditions
+ * 
+ * Provides methods to validate function arguments and application state
+ * with consistent error handling and messaging.
+ */
+export default class ValidationUtils {
+
+    /**
+     * Validate that a state condition is true
+     * 
+     * @param condition - The condition to validate
+     * @param message - Error message to throw if condition is false
+     * @throws {Error} If condition is false
+     * 
+     * @example
+     * ```typescript
+     * ValidationUtils.validateState(wallet.isInitialized, 'Wallet must be initialized');
+     * ```
+     */
+    public static validateState(condition: boolean, message: string): void {
+        if (!condition) {
+            throw new Error(`Invalid State: ${message}`);
+        }
+    }
+
+    /**
+     * Validate that an argument condition is true
+     * 
+     * @param condition - The condition to validate
+     * @param argumentName - Name of the argument being validated
+     * @param message - Optional additional error message
+     * @throws {Error} If condition is false
+     * 
+     * @example
+     * ```typescript
+     * ValidationUtils.validateArgument(
+     *   typeof amount === 'number',
+     *   'amount',
+     *   'must be a number'
+     * );
+     * ```
+     */
+    public static validateArgument(condition: boolean, argumentName: string, message = ""): void {
+        if (!condition) {
+            throw new Error(`Invalid Argument: ${argumentName}. ${message}`);
+        }
+    }
+
+    /**
+     * Validate that an argument is of the expected type
+     * 
+     * @param argument - The argument to validate
+     * @param type - Expected type (string name or constructor function)
+     * @param argumentName - Name of the argument being validated
+     * @throws {TypeError} If argument is not of expected type
+     * 
+     * @example
+     * ```typescript
+     * ValidationUtils.validateArgumentType(buffer, 'Buffer', 'data');
+     * ValidationUtils.validateArgumentType(wallet, Wallet, 'wallet');
+     * ValidationUtils.validateArgumentType(amount, 'number', 'amount');
+     * ```
+     */
+    public static validateArgumentType<T>(argument: unknown, type: string | Class<T>, argumentName?: string): void {
+        argumentName = argumentName || '(unknown name)';
+        if (isString(type)) {
+            if (type === 'Buffer') {
+                if (!Buffer.isBuffer(argument)) {
+                    throw new TypeError(`Invalid Argument for ${argumentName}, expected ${type} but got ${typeof argument}`);
+                }
+            } else if (typeof argument !== type) {
+                throw new TypeError(`Invalid Argument for ${argumentName}, expected ${type} but got ${typeof argument}`);
+            }
+        } else {
+            if (!(argument instanceof type)) {
+                throw new TypeError(`Invalid Argument for ${argumentName}, expected ${type} but got ${typeof argument}`);
+            }
+        }
+    }
+}

package/src/utils/WalletUtils.ts

@@ -0,0 +1,522 @@
+import {rostrumProvider} from "../network/RostrumProvider";
+import {AccountIndexes, AccountKeys, AddressKey, Balance} from "../models/wallet.entities";
+import * as Bip39 from 'bip39';
+import bigDecimal from "js-big-decimal";
+import {ITXHistory, ITXInput, ITXOutput} from "../models/rostrum.entities";
+import {Address, AddressType, HDPrivateKey, Networkish} from "libnexa-ts";
+
+import {isNil} from "lodash-es";
+import {BaseAccount} from "../wallet/accounts/interfaces/BaseAccountInterface";
+import DAppAccount from "../wallet/accounts/models/DappAccount";
+import DefaultAccount from "../wallet/accounts/models/DefaultAccount";
+import VaultAccount from "../wallet/accounts/models/VaultAccount";
+import {TransactionEntity, TxEntityState} from "../models/transaction.entities";
+import {currentTimestamp, isNullOrEmpty} from "./CommonUtils";
+
+export enum TxTokenType {
+    NO_GROUP,
+    CREATE,
+    MINT,
+    MELT,
+    RENEW,
+    TRANSFER
+}
+
+export enum AccountType {
+    NEXA_ACCOUNT,
+    VAULT_ACCOUNT,
+    DAPP_ACCOUNT,
+}
+
+export function isValidNexaAddress(address: string, network: Networkish, type = AddressType.PayToScriptTemplate) {
+    return Address.isValid(address, network, type);
+}
+
+export function generateMasterKey(mnemonic: string, passphrase?: string | undefined) {
+    const seed = Bip39.mnemonicToSeedSync(mnemonic, passphrase);
+    const masterKey = HDPrivateKey.fromSeed(seed);
+    return masterKey.deriveChild(44, true).deriveChild(29223, true);
+}
+
+export function generateAccountKey(masterKey: HDPrivateKey, account: number) {
+    return masterKey.deriveChild(account, true);
+}
+
+export function generateKeysAndAddresses(accountKey: HDPrivateKey, fromRIndex: number, rIndex: number, fromCIndex: number, cIndex: number): AccountKeys {
+    if (fromRIndex < 0) {
+        throw new Error(`Can not generate keys with fromRIndex ${fromRIndex}. must be >= 0.`);
+    }
+    if (fromCIndex < 0) {
+        throw new Error(`Can not generate keys with fromCIndex ${fromCIndex}. must be >= 0.`);
+    }
+    let receive = accountKey.deriveChild(0, false);
+    let change = accountKey.deriveChild(1, false);
+    let rKeys: AddressKey[] = [], cKeys: AddressKey[] = [];
+    for (let index = fromRIndex; index < rIndex; index++) {
+        let k = receive.deriveChild(index, false);
+        let addr = k.privateKey.toAddress().toString();
+        rKeys.push({key: k, address: addr, balance: "0", tokensBalance: {}});
+    }
+    for (let index = fromCIndex; index < cIndex; index++) {
+        let k = change.deriveChild(index, false);
+        let addr = k.privateKey.toAddress().toString();
+        cKeys.push({key: k, address: addr, balance: "0", tokensBalance: {}});
+    }
+    return {receiveKeys: rKeys, changeKeys: cKeys};
+}
+
+export function generateKeyAndAddress(accountKey: HDPrivateKey, rIndex: number): AddressKey {
+    let receive = accountKey.deriveChild(0, false);
+    let k = receive.deriveChild(rIndex, false);
+    let addr = k.privateKey.toAddress().toString();
+    return ({key: k, address: addr, balance: "0", tokensBalance: {}});
+}
+
+async function discoverUsedAccountIndexes(deriveKey: HDPrivateKey) {
+    let lastUsed = -1, index = 0, toScan = 20;
+
+    while (toScan > 0) {
+        toScan--;
+        let rAddr = deriveKey.deriveChild(index, false).privateKey.toAddress().toString();
+        let isUsed = await isAddressUsed(rAddr);
+        if (isUsed) {
+            lastUsed = index;
+            toScan = 20;
+        }
+        index++;
+    }
+    // return the last used index, returns -1 if no indexes are used
+    return lastUsed;
+}
+
+export async function discoverNexaAccount(accountKey: HDPrivateKey) {
+
+    let receiveKey = accountKey.deriveChild(0, false);
+    let changeKey = accountKey.deriveChild(1, false);
+
+    let rIndexPromise = discoverUsedAccountIndexes(receiveKey);
+    let cIndexPromise = discoverUsedAccountIndexes(changeKey);
+
+    let [rIndex, cIndex] = await Promise.all([rIndexPromise, cIndexPromise]);
+
+    // get the index that is the last used nexa addr
+    let indexes: AccountIndexes = { rIndex: rIndex, cIndex: cIndex };
+
+    return indexes;
+}
+
+export async function discoverNexaAccounts(masterKey: HDPrivateKey) {
+    let accounts: DefaultAccount[] = [];
+
+    let index = 0;
+    while (true) {
+        const nexaAccountKey = generateAccountKey(masterKey, index);
+        const indexes = await discoverNexaAccount(nexaAccountKey);
+        if (indexes.rIndex < 0 && indexes.cIndex < 0)
+        {
+            break;
+        }
+        if (indexes.rIndex < 0) {
+            indexes.rIndex = 0;
+        }
+        if (indexes.cIndex < 0) {
+            indexes.cIndex = 0;
+        }
+        // make account after break check, otherwise we might push an empty account
+        const nexaAccount = new DefaultAccount(index, indexes, generateKeysAndAddresses(nexaAccountKey, indexes.rIndex + 1, indexes.rIndex + 20, indexes.cIndex + 1, indexes.cIndex + 20))
+        await nexaAccount.loadBalances()
+        accounts.push(nexaAccount);
+        if (index == 0) {
+            index = 100;
+        }
+        else {
+            index++;
+        }
+    }
+    if (accounts.length == 0) {
+        // default account was unused but we need to populate at least one account,
+        // make the default account here
+        let defaultNexaAccountKey = generateAccountKey(masterKey, 0);
+        // get the last used indexes, -1 means unused
+        let defaultIndexes: AccountIndexes = { rIndex: 0, cIndex: 0 };
+        const defaultAccount = new DefaultAccount(0, defaultIndexes, generateKeysAndAddresses(defaultNexaAccountKey, defaultIndexes.rIndex, defaultIndexes.rIndex + 20, defaultIndexes.cIndex, defaultIndexes.cIndex + 20))
+        await defaultAccount.loadBalances()
+        accounts.push(defaultAccount)
+    }
+    return accounts;
+}
+
+async function findUsedVaultAccounts(masterKey: HDPrivateKey) {
+    // all vaults are in bip44 account 1
+    let vaultAccountKey = generateAccountKey(masterKey, 1);
+    // all vaults are in the external chain
+    let vaultChain = vaultAccountKey.deriveChild(0, false);
+    // get the index that is the last used vault
+    return await discoverUsedAccountIndexes(vaultChain);
+}
+
+export async function discoverVaults(masterKey: HDPrivateKey) {
+    let accounts: VaultAccount[] = [];
+    // all vaults are in bip44 account 1
+    let vaultAccountKey = generateAccountKey(masterKey, 1);
+    // find the next unused vault
+    let lastUsedVaultIndex: number = await findUsedVaultAccounts(masterKey);
+    // if all vaults unused, generate at least the first vault account
+    if (lastUsedVaultIndex < 0) lastUsedVaultIndex = 0;
+    // for each vault found, make the DefaultAccount for that vault
+    for (let index = 0; index <= lastUsedVaultIndex; index++)
+    {
+        const vaultAccount = new VaultAccount(1, index, generateKeyAndAddress(vaultAccountKey, index))
+        await vaultAccount.loadBalances();
+        accounts.push(vaultAccount);
+    }
+    return accounts;
+}
+
+async function findUsedDappAccounts(masterKey: HDPrivateKey) {
+    // all dApp accounts are in bip44 account 2
+    let dappAccountKey = generateAccountKey(masterKey, 2);
+    // all dApp accounts use the external chain
+    let dappChain = dappAccountKey.deriveChild(0, false);
+    // get the index that is the next unused dApp account
+    return await discoverUsedAccountIndexes(dappChain);
+}
+
+export async function discoverDappAccounts(masterKey: HDPrivateKey) {
+    let accounts: DAppAccount[] = [];
+    // all dApp accounts are in bip44 account 2
+    let dappAccountKey = generateAccountKey(masterKey, 2);
+    // find the next unused dapp account
+    let lastUsedDappIndex: number = await findUsedDappAccounts(masterKey);
+    // if all dapp accounts unused, generate at least the first dapp account
+    if (lastUsedDappIndex < 0) lastUsedDappIndex = 0;
+    // for each dApp account found, make the DefaultAccount for that dApp account
+    // for each vault found, make the DefaultAccount for that vault
+    for (let index = 0; index <= lastUsedDappIndex; index++)
+    {
+        const dappAccount = new DAppAccount(2, index, generateKeyAndAddress(dappAccountKey, index))
+        await dappAccount.loadBalances();
+        accounts.push(dappAccount);
+    }
+    return accounts;
+}
+
+export async function discoverWallet(masterKey: HDPrivateKey) {
+    let accounts: BaseAccount[] = [];
+    // accounts 0, 100+
+    const nexaAccounts = await discoverNexaAccounts(masterKey);
+    // vaults in bip44 account 1
+    const vaultAccounts = await discoverVaults(masterKey);
+    // dApp accounts in bip44 account 2
+    const dappAccounts = await discoverDappAccounts(masterKey);
+    // 3 - 99 are reserved and will go here when added
+    accounts = accounts.concat(nexaAccounts);
+    accounts = accounts.concat(vaultAccounts);
+    accounts = accounts.concat(dappAccounts);
+    return accounts;
+}
+
+async function isAddressUsed(address: string) {
+    try {
+        let firstUse = await rostrumProvider.getFirstUse(address);
+        return firstUse.tx_hash && firstUse.tx_hash !== "";
+    } catch (e) {
+        if (e instanceof Error && e.message.includes("not found")) {
+            return false;
+        }
+        throw e;
+    }
+}
+
+async function getKeyTokenBalance(key: AddressKey) {
+    let tokensBalance = await rostrumProvider.getTokensBalance(key.address);
+    let balance: Record<string, Balance> = {};
+
+    for (const cToken in tokensBalance.confirmed) {
+        if (tokensBalance.confirmed[cToken] != 0) {
+            balance[cToken] = { confirmed: BigInt(tokensBalance.confirmed[cToken]).toString(), unconfirmed: "0" }
+        }
+    }
+
+    for (const uToken in tokensBalance.unconfirmed) {
+        if (tokensBalance.unconfirmed[uToken] != 0) {
+            if (balance[uToken]) {
+                balance[uToken].unconfirmed = BigInt(tokensBalance.unconfirmed[uToken]).toString();
+            } else {
+                balance[uToken] = { confirmed: "0", unconfirmed: BigInt(tokensBalance.unconfirmed[uToken]).toString() }
+            }
+        }
+    }
+
+    return balance;
+}
+
+async function getAndUpdateAddressKeyBalance(key: AddressKey) {
+    let balance = await rostrumProvider.getBalance(key.address);
+    key.balance = (BigInt(balance.confirmed) + BigInt(balance.unconfirmed)).toString();
+    key.tokensBalance = await getKeyTokenBalance(key);
+
+    return balance;
+}
+
+export async function fetchTotalBalance(keys: AddressKey[]) {
+    let promises: Promise<Balance>[] = [];
+    keys.forEach(key => {
+        let b = getAndUpdateAddressKeyBalance(key);
+        promises.push(b);
+    });
+
+    return await Promise.all(promises);
+}
+
+export function sumBalance(balances: Balance[]): Balance {
+    let confirmed = new bigDecimal(0), unconfirmed = new bigDecimal(0);
+    balances.forEach(b => {
+        confirmed = confirmed.add(new bigDecimal(b.confirmed));
+        unconfirmed = unconfirmed.add(new bigDecimal(b.unconfirmed));
+    });
+    return {confirmed: confirmed.getValue(), unconfirmed: unconfirmed.getValue()};
+}
+
+export function sumTokensBalance(balances: Record<string, Balance>[]) {
+    let tokensBalance: Record<string, Balance> = {};
+    balances.forEach(b => {
+        for (const key in b) {
+            if (tokensBalance[key]) {
+                tokensBalance[key].confirmed = (BigInt(tokensBalance[key].confirmed) + BigInt(b[key].confirmed)).toString();
+                tokensBalance[key].unconfirmed = (BigInt(tokensBalance[key].unconfirmed) + BigInt(b[key].unconfirmed)).toString();
+            } else {
+                tokensBalance[key] = { confirmed: b[key].confirmed, unconfirmed: b[key].unconfirmed };
+            }
+        }
+    });
+
+    return tokensBalance;
+}
+
+export async function fetchTransactionsHistory(addresses: string[], fromHeight: number) {
+    let index = 0, i = 0, data = new Map<string, ITXHistory>(), maxHeight = fromHeight;
+
+    for (let address of addresses) {
+        i++;
+        let txHistory = await rostrumProvider.getTransactionsHistory(address);
+        if (txHistory && txHistory.length > 0) {
+            index = i;
+            for (let tx of txHistory) {
+                if (tx.height === 0 || tx.height > fromHeight) {
+                    maxHeight = Math.max(maxHeight, tx.height);
+                    data.set(tx.tx_hash, tx);
+                }
+            }
+        }
+    }
+
+    return {index: index, txs: data, lastHeight: maxHeight};
+}
+
+async function rescanAddressesHistory(addresses: string[]) {
+    let index = 0, i = 0, minHeight = Number.MAX_SAFE_INTEGER;
+
+    for (let address of addresses) {
+        i++;
+        let txHistory = await rostrumProvider.getTransactionsHistory(address);
+        if (!isNil(txHistory)) {
+            index = i;
+            let heights = txHistory.filter(tx => tx.height > 0).map(h => h.height);
+            if (!isNil(heights)) {
+                minHeight = Math.min(minHeight, ...heights);
+            }
+        }
+    }
+
+    return {index: (index > 0 ? index + 1 : 0), height: (minHeight == Number.MAX_SAFE_INTEGER ? 0 : minHeight)};
+}
+
+export async function getNextAccountIndex(accountType: AccountType, masterKey: HDPrivateKey) {
+    if (accountType == AccountType.NEXA_ACCOUNT) {
+        let defaultNexaAccountKey = generateAccountKey(masterKey, 0);
+        const defaultIndexes = await discoverNexaAccount(defaultNexaAccountKey);
+        if (defaultIndexes.rIndex < 0 && defaultIndexes.cIndex < 0){
+            return 0;
+        }
+        else {
+            // account 0 was not empty
+            for (let index = 100; ; index++) {
+                const nexaAccountKey = generateAccountKey(masterKey, index);
+                const indexes = await discoverNexaAccount(nexaAccountKey);
+                if (indexes.rIndex < 0 && indexes.cIndex < 0)
+                {
+                    return index;
+                }
+            }
+        }
+    }
+    else if (accountType == AccountType.VAULT_ACCOUNT) {
+        // find the next unused vault
+        const lastUsedVault: number = await findUsedVaultAccounts(masterKey);
+        return lastUsedVault + 1;
+    }
+    else if (accountType == AccountType.DAPP_ACCOUNT) {
+        // find the next unused dapp account
+        const lastUsedDappAccount: number = await findUsedDappAccounts(masterKey);
+        return lastUsedDappAccount + 1;
+    }
+    else {
+        throw new Error("Can not get next account index. Invalid accountType.");
+    }
+}
+
+export async function classifyTransaction(txHistory: ITXHistory, myAddresses: string[]) {
+    let t = await rostrumProvider.getTransaction(txHistory.tx_hash);
+
+    let outputs = t.vout.filter(utxo => !isNil(utxo.scriptPubKey.addresses));
+
+    let isOutgoing = t.vin.length > 0 && myAddresses.includes(t.vin[0].addresses[0]);
+    let isIncoming = !isOutgoing || outputs.every(utxo => myAddresses.includes(utxo.scriptPubKey.addresses[0]));
+    let isConfirmed = t.height > 0;
+
+    let txEntry = {} as TransactionEntity;
+    txEntry.txId = t.txid;
+    txEntry.txIdem = t.txidem;
+    txEntry.height = isConfirmed ? t.height : 0;
+    txEntry.time = isConfirmed ? t.time : currentTimestamp();
+    txEntry.fee = t.fee_satoshi;
+
+    if (isOutgoing && isIncoming) {
+        txEntry.state = 'both';
+        txEntry.value = "0";
+        txEntry.payTo = "Payment to yourself";
+    } else if (isIncoming) {
+        txEntry.state = 'incoming';
+        let utxos = outputs.filter(utxo => myAddresses.includes(utxo.scriptPubKey.addresses[0]));
+        let amount = new bigDecimal(0);
+        utxos.forEach(utxo => {
+            amount = amount.add(new bigDecimal(utxo.value_satoshi));
+        });
+        txEntry.value = amount.getValue();
+        txEntry.payTo = utxos[0].scriptPubKey.addresses[0];
+    } else if(isOutgoing) {
+        txEntry.state = 'outgoing';
+        let utxos = outputs.filter(utxo => !myAddresses.includes(utxo.scriptPubKey.addresses[0]));
+        let amount = new bigDecimal(0);
+        utxos.forEach(utxo => {
+            amount = amount.add(new bigDecimal(utxo.value_satoshi));
+        });
+        txEntry.value = amount.getValue();
+        txEntry.payTo = utxos[0].scriptPubKey.addresses[0];
+    }
+
+    let [txType, txGroup, tokenAmount, extraGroup] = classifyTokenTransaction(t.vin, outputs, txEntry.state, myAddresses);
+    txEntry.txGroupType = txType;
+    txEntry.token = txGroup;
+    txEntry.tokenAmount = tokenAmount;
+    txEntry.extraGroup = extraGroup;
+
+    return txEntry;
+}
+
+function classifyTokenTransaction(vin: ITXInput[], vout: ITXOutput[], txState: TxEntityState, myAddresses: string[]): [TxTokenType, string, string, string] {
+    let groupInputs = vin.filter(input => !isNullOrEmpty(input.group));
+    let groupOutputs = vout.filter(output => !isNullOrEmpty(output.scriptPubKey.group));
+
+    if (isNullOrEmpty(groupInputs) && isNullOrEmpty(groupOutputs)) {
+        return [TxTokenType.NO_GROUP, "none", "0", "none"];
+    }
+
+    let myGroupInputs = groupInputs.filter(input => myAddresses.includes(input.addresses[0]));
+    let myGroupOutputs = groupOutputs.filter(output => myAddresses.includes(output.scriptPubKey.addresses[0]));
+
+    if (isNullOrEmpty(myGroupInputs) && isNullOrEmpty(myGroupOutputs)) {
+        return [TxTokenType.NO_GROUP, "none", "0", "none"];
+    }
+
+    if (isNullOrEmpty(groupInputs)) {
+        let group = myGroupOutputs.find(output => BigInt(output.scriptPubKey.groupQuantity) < 0n)?.scriptPubKey.group ?? "none";
+        return [TxTokenType.CREATE, group, "0", "none"];
+    }
+
+    if (isNullOrEmpty(groupOutputs)) {
+        if (txState === 'incoming') {
+            return [TxTokenType.NO_GROUP, "none", "0", "none"];
+        }
+
+        let inputs = myGroupInputs.filter(input => BigInt(input.groupQuantity) > 0n);
+        if (!isNullOrEmpty(inputs)) {
+            let amount = new bigDecimal(0);
+            inputs.forEach(utxo => {
+                amount = amount.add(new bigDecimal(utxo.groupQuantity));
+            });
+            let group = inputs[0].group;
+            let extraGroup = myGroupInputs.find(input => BigInt(input.groupQuantity) < 0n && inputs[0].group != input.group)?.group ?? "none";
+            return [TxTokenType.MELT, group, amount.getValue(), extraGroup];
+        }
+
+        let group = myGroupInputs.find(input => BigInt(input.groupQuantity) < 0n)?.group ?? "none";
+        let extraGroup = myGroupInputs.find(input => BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [TxTokenType.MELT, group, "0", extraGroup];
+    }
+
+    let tokenInputs = groupInputs.filter(input => BigInt(input.groupQuantity) > 0n);
+    let tokenOutputs = groupOutputs.filter(output => BigInt(output.scriptPubKey.groupQuantity) > 0n);
+
+    if (isNullOrEmpty(tokenInputs) && isNullOrEmpty(tokenOutputs)) {
+        let group = groupInputs.find(input => BigInt(input.groupQuantity) < 0n)?.group ?? "none";
+        let extraGroup = groupOutputs.find(output => BigInt(output.scriptPubKey.groupQuantity) < 0n && group != output.scriptPubKey.group)?.scriptPubKey.group ?? "none";
+        return [TxTokenType.RENEW, extraGroup !== 'none' ? extraGroup : group, "0", extraGroup !== 'none' ? group : extraGroup];
+    }
+
+    if (isNullOrEmpty(tokenInputs)) {
+        let group = tokenOutputs[0].scriptPubKey.group;
+        let amount = new bigDecimal(0);
+        tokenOutputs.forEach(utxo => {
+            amount = amount.add(new bigDecimal(utxo.scriptPubKey.groupQuantity));
+        });
+        let extraGroup = groupInputs.find(input => BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [TxTokenType.MINT, group, amount.getValue(), extraGroup];
+    }
+
+    if (isNullOrEmpty(tokenOutputs)) {
+        let group = tokenInputs[0].group;
+        let amount = new bigDecimal(0);
+        tokenInputs.forEach(utxo => {
+            amount = amount.add(new bigDecimal(utxo.groupQuantity));
+        });
+        let extraGroup = groupInputs.find(input => BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [TxTokenType.MELT, group, amount.getValue(), extraGroup];
+    }
+
+    let outQuantitySum = tokenOutputs.map(output => BigInt(output.scriptPubKey.groupQuantity)).reduce((a, b) => a + b, 0n);
+    let inQuantitySum = tokenInputs.map(input => BigInt(input.groupQuantity)).reduce((a, b) => a + b, 0n);
+
+    if (outQuantitySum > inQuantitySum) {
+        let group = tokenOutputs[0].scriptPubKey.group;
+        let extraGroup = groupInputs.find(input => BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [TxTokenType.MINT, group, (outQuantitySum - inQuantitySum).toString(), extraGroup];
+    }
+
+    if (inQuantitySum > outQuantitySum) {
+        let group = tokenInputs[0].group;
+        let extraGroup = groupInputs.find(input => BigInt(input.groupQuantity) < 0n && group != input.group)?.group ?? "none";
+        return [TxTokenType.MELT, group, (inQuantitySum - outQuantitySum).toString(), extraGroup];
+    }
+
+    let group = tokenOutputs[0].scriptPubKey.group;
+    let amount = "";
+    if (txState === 'incoming') {
+        amount = tokenOutputs
+            .filter(output => myAddresses.includes(output.scriptPubKey.addresses[0]))
+            .map(output => BigInt(output.scriptPubKey.groupQuantity))
+            .reduce((a, b) => a + b, 0n)
+            .toString();
+    } else if (txState === 'outgoing') {
+        amount = tokenOutputs
+            .filter(output => !myAddresses.includes(output.scriptPubKey.addresses[0]))
+            .map(output => BigInt(output.scriptPubKey.groupQuantity))
+            .reduce((a, b) => a + b, 0n)
+            .toString();
+    } else {
+        amount = "0";
+    }
+
+    return [TxTokenType.TRANSFER, group, amount, "none"];
+}