nexa-wallet-sdk 0.1.2

package/src/wallet/transactions/WalletTransactionCreator.ts

@@ -0,0 +1,145 @@
+import {PrivateKey, TransactionBuilder} from "libnexa-ts";
+import {rostrumProvider} from "../../network/RostrumProvider";
+import {
+    buildCreateGroupTransaction,
+    populateAndDuplicateTokenAuths,
+    populateNexaInputsAndChange,
+    populateTokenAuth,
+    populateTokenInputsAndChange,
+    prepareDeleteTransaction
+} from "../../utils/TXUtils";
+import {BaseAccount} from "../accounts/interfaces/BaseAccountInterface";
+import {AddressKey} from "../../models/wallet.entities";
+import {TransactionCreator} from "./interfaces/TransactionCreator";
+import {keys} from "lodash-es";
+import {PermissionLabel} from "../../models/transaction.entities";
+
+export default class WalletTransactionCreator extends TransactionCreator {
+
+    private  _keysToSign: PrivateKey[] = [];
+    private _account!: BaseAccount;
+
+    constructor(fromAccount: BaseAccount, tx?: TransactionBuilder | string | Buffer) {
+        super(tx)
+        this._account = fromAccount
+        this.validateAccount()
+    }
+
+    public fromAccount(fromAccount: BaseAccount): this {
+        this._account = fromAccount
+        return this
+    }
+
+    public parseTxHex(tx: string) {
+        this.builder.push(async () => {
+            const txBuilder = new TransactionBuilder(tx)
+            const newTxBuilder = new TransactionBuilder()
+            const oldInputs = txBuilder.transaction.inputs
+            for (const input of oldInputs) {
+                const utxo = await rostrumProvider.getUtxo(input.outpoint.toString('hex'))
+                newTxBuilder.from({
+                    outpoint: utxo.tx_hash,
+                    amount: utxo.amount,
+                    scriptPubKey: utxo.scriptpubkey
+                })
+                const foundKey = this.findPrivateKeyFromAddress(utxo.addresses[0])
+                if(foundKey) {
+                    this._keysToSign.push(foundKey.key.privateKey)
+                }
+
+            }
+            newTxBuilder.transaction.outputs = txBuilder.transaction.outputs
+
+        })
+
+        return this
+    }
+
+    public parseTxBuffer(tx: Buffer) {
+        this.builder.push(async () => {
+            this.transactionBuilder = new TransactionBuilder(tx);
+        })
+
+        return this
+    }
+
+    public mint(token: string, amount: string): this {
+        this.builder.push(async() => {
+            let toAddr = this._account.accountKeys.receiveKeys.at(-1)!.address;
+            this.tokenAction(toAddr, amount, token, 'mint')
+        })
+
+        return this
+    }
+
+    public melt(token: string, amount: string): this {
+        this.builder.push(async() => {
+            let toAddr = this._account.accountKeys.receiveKeys.at(-1)!.address;
+            this.tokenAction(toAddr, amount, token, 'melt')
+        })
+
+        return this
+    }
+
+    public populate(): this {
+        this.validateAccount();
+        this.builder.push(async () => {
+            let tK: PrivateKey[] = []
+            let nK: PrivateKey[] = []
+            if(this.tokens.size > 0) {
+                for (const tokenAction of this.tokens) {
+                    if(tokenAction.action == 'mint' || tokenAction.action == 'melt') {
+                        tK = tK.concat(await populateTokenAuth(this.transactionBuilder, this._account.accountKeys, tokenAction.token!, tokenAction.action))
+                    } else if (tokenAction.action == 'group') {
+                        tK = tK.concat(await buildCreateGroupTransaction(this.transactionBuilder, this._account.accountKeys, tokenAction.extraData?.opReturnData!, this.network))
+                    } else if (tokenAction.action == 'subgroup') {
+                       tK = tK.concat(await populateTokenAuth(this.transactionBuilder, this._account.accountKeys, tokenAction.parentToken!, 'subgroup', tokenAction.token, this._account.accountKeys.receiveKeys.at(-1)!.address));
+                    } else if(tokenAction.action == 'renew') {
+                        tK = tK.concat(await populateAndDuplicateTokenAuths(this.transactionBuilder, this._account.accountKeys, tokenAction.token!, tokenAction.extraData!.perms!, tokenAction.extraData!.address!))
+                    } else if(tokenAction.action == 'delete') {
+                        tK = tK.concat(await prepareDeleteTransaction(this.transactionBuilder, this._account.accountKeys, tokenAction.extraData!.outpoint!))
+                    } else {
+                        tK = tK.concat(await populateTokenInputsAndChange(this.transactionBuilder, this._account.accountKeys, tokenAction.token!, tokenAction.amount))
+                    }
+
+                    this._keysToSign!.concat(tK)
+                }
+            }
+
+            nK = nK.concat(await populateNexaInputsAndChange(this.transactionBuilder, this._account.accountKeys, this.totalValue, this.txOptions))
+            this._keysToSign! = tK.concat(nK)
+        })
+
+        return this
+    }
+
+    public sign(): this {
+        this.builder.push(async () => {
+            const blockHeight = await rostrumProvider.getBlockTip()
+            this.transactionBuilder.lockUntilBlockHeight(blockHeight.height).sign(this._keysToSign!)
+        })
+
+        return this
+    }
+
+    /**
+     * Validates that the account has the necessary keys before performing operations
+     * @throws Error if account or keys are not properly initialized
+     */
+    private validateAccount(): void {
+        if (!this._account) {
+            throw new Error('Account must be set before performing transactions');
+        }
+        if (!this._account.accountKeys) {
+            throw new Error('Account keys are not initialized');
+        }
+        if (!this._account.accountKeys.receiveKeys || this._account.accountKeys.receiveKeys.length === 0) {
+            throw new Error('No receive keys available in account');
+        }
+    }
+
+    private findPrivateKeyFromAddress(addr: string): AddressKey | undefined {
+        const keys: AddressKey[] = this._account.accountKeys.receiveKeys.concat(this._account.accountKeys.changeKeys)
+        return keys.find(key => key.address === addr)
+    }
+}

package/src/wallet/transactions/WatchOnlyTransactionCreator.ts

@@ -0,0 +1,189 @@
+import {
+    AddressType,
+    TransactionBuilder,
+} from "libnexa-ts";
+import {WatchOnlyAddress} from "../../models/wallet.entities";
+import {TransactionCreator} from "./interfaces/TransactionCreator";
+import {
+    watchOnlyBuildCreateGroupTransaction, watchOnlyPopulateAndDuplicateTokenAuths,
+    watchOnlyPopulateNexaInputsAndChange,
+    watchOnlyPopulateTokenAuth, watchOnlyPopulateTokenInputsAndChange, watchOnlyPrepareDeleteTransaction
+} from "../../utils/WatchOnlyTXUtils";
+import {isString} from "lodash-es";
+import {rostrumProvider} from "../../network/RostrumProvider";
+import {PermissionLabel} from "../../models/transaction.entities";
+import {isValidNexaAddress} from "../../utils/WalletUtils";
+
+/**
+ * WatchOnlyTransactionCreator extends TransactionCreator to handle transaction creation
+ * for watch-only wallets. It manages addresses without private keys and delegates
+ * UTXO selection and input population to specialized utility functions.
+ */
+export default class WatchOnlyTransactionCreator extends TransactionCreator {
+
+
+    /** Addresses that need to be signed with (populated during transaction building) */
+    private _addressesToSignWith: string[] = [];
+    /** Available addresses for input selection and change */
+    private _availableAddresses: WatchOnlyAddress[] = []
+
+    /**
+     * Creates a new WatchOnlyTransactionCreator
+     * @param tx Optional existing transaction builder or transaction data
+     */
+    constructor(tx?: TransactionBuilder | string | Buffer) {
+        super(tx)
+    }
+
+    /**
+     * Sets the source addresses for transaction inputs
+     * @param address Single address string, array of addresses, or WatchOnlyAddress objects
+     * @returns This instance for chaining
+     */
+    public from(address: string | string[] | WatchOnlyAddress[] | WatchOnlyAddress): this {
+        if (isString(address)) {
+
+            if (!isValidNexaAddress(address, this.network) && !isValidNexaAddress(address, this.network, AddressType.PayToPublicKeyHash)) {
+                throw new Error('Invalid Address.');
+            }
+            // Single address string
+            this._availableAddresses.push({address: address});
+        } else if(Array.isArray(address)) {
+            // Array of addresses or WatchOnlyAddress objects
+            address.forEach((addr) => {
+                if (isString(addr)) {
+                    if (!isValidNexaAddress(addr, this.network) && !isValidNexaAddress(addr, this.network, AddressType.PayToPublicKeyHash)) {
+                        throw new Error('Invalid Address.');
+                    }
+                    // String address
+                    this._availableAddresses.push({address: addr});
+                } else if (addr && typeof addr === 'object' && 'address' in addr) {
+                    // WatchOnlyAddress object
+                    this._availableAddresses.push(<WatchOnlyAddress>addr);
+                }
+            })
+        } else if(address.address != null) {
+            // Single WatchOnlyAddress object
+            this._availableAddresses.push(<WatchOnlyAddress>address)
+        }
+        return this
+    }
+
+    /**
+     * Adds a token minting operation to the transaction
+     * @param token Token ID to mint
+     * @param amount Amount to mint
+     * @param toAddr Destination address for minted tokens
+     * @returns This instance for chaining
+     */
+    public mint(token: string, amount: string, toAddr:string): this {
+        this.builder.push(async() => {
+            this.tokenAction(toAddr, amount, token, 'mint')
+        })
+
+        return this
+    }
+
+    /**
+     * Adds a token melting operation to the transaction
+     * @param token Token ID to melt
+     * @param amount Amount to melt
+     * @param toAddr Destination address for melted tokens
+     * @returns This instance for chaining
+     */
+    public melt(token: string, amount: string, toAddr:string): this {
+        this.builder.push(async() => {
+            this.tokenAction(toAddr, amount, token, 'melt')
+        })
+
+        return this
+    }
+
+    /**
+     * Populates the transaction with inputs and outputs based on the configured actions.
+     * Handles different token operations (mint, melt, group creation, etc.) and
+     * populates NEXA inputs for transaction fees.
+     * @returns This instance for chaining
+     */
+    public populate(): this {
+        this.builder.push(async () => {
+            let tokenAddresses: string[] = []
+            let nexaAddresses: string[] = []
+
+            // 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 watchOnlyPopulateTokenAuth(this.transactionBuilder, this._availableAddresses, tokenAction.token!, tokenAction.action))
+                    } else if (tokenAction.action == 'group') {
+                        // Handle group token creation
+                        tokenAddresses = tokenAddresses.concat(await watchOnlyBuildCreateGroupTransaction(this.transactionBuilder, this._availableAddresses, tokenAction.token!, this.network))
+                    } else if (tokenAction.action == 'subgroup') {
+                        // Handle subgroup token creation
+                        tokenAddresses = tokenAddresses.concat(await watchOnlyPopulateTokenAuth(this.transactionBuilder, this._availableAddresses, tokenAction.parentToken!, tokenAction.action, tokenAction.token));
+                    } else if(tokenAction.action == 'renew') {
+                        // Handle authority renewal
+                        tokenAddresses = tokenAddresses.concat(await watchOnlyPopulateAndDuplicateTokenAuths(this.transactionBuilder, this._availableAddresses, tokenAction.token!, tokenAction.extraData!.perms!, tokenAction.extraData?.address!))
+                    } else if(tokenAction.action == 'delete') {
+                        // Handle authority deletion
+                        tokenAddresses = tokenAddresses.concat(await watchOnlyPrepareDeleteTransaction(this.transactionBuilder, this._availableAddresses, tokenAction.extraData!.outpoint!))
+                    } else {
+                        // Handle regular token transfers
+                        tokenAddresses = tokenAddresses.concat(await watchOnlyPopulateTokenInputsAndChange(this.transactionBuilder, this._availableAddresses, tokenAction.token!, tokenAction.amount))
+                    }
+
+                    // Accumulate addresses that need signing
+                    this._addressesToSignWith!.concat(tokenAddresses)
+                }
+            }
+
+            // Populate NEXA inputs for transaction fees and change
+            nexaAddresses = nexaAddresses.concat(await watchOnlyPopulateNexaInputsAndChange(this.transactionBuilder, this._availableAddresses, this.totalValue, this.txOptions))
+
+            // Combine all addresses that need signing
+            this._addressesToSignWith! = tokenAddresses.concat(nexaAddresses)
+        })
+
+        return this
+    }
+
+    /**
+     * Parse transaction from buffer (not implemented for watch-only)
+     * @param tx Transaction buffer
+     * @returns This instance for chaining
+     * @throws Error indicating method not implemented
+     */
+    public parseTxBuffer(tx: Buffer): this {
+        this.builder.push(async () => {
+            this.transactionBuilder = new TransactionBuilder(tx);
+        })
+        return this
+    }
+
+    /**
+     * Parse transaction from hex string (not implemented for watch-only)
+     * @param tx Transaction hex string
+     * @returns This instance for chaining
+     * @throws Error indicating method not implemented
+     */
+    public parseTxHex(tx: string) {
+        this.builder.push(async () => {
+            const txBuilder = new TransactionBuilder(tx)
+            const newTxBuilder = new TransactionBuilder()
+            const oldInputs = txBuilder.transaction.inputs
+            for (const input of oldInputs) {
+                const utxo = await rostrumProvider.getUtxo(input.outpoint.toString('hex'))
+                newTxBuilder.from({
+                    outpoint: utxo.tx_hash,
+                    amount: utxo.amount,
+                    scriptPubKey: utxo.scriptpubkey
+                })
+            }
+            newTxBuilder.transaction.outputs = txBuilder.transaction.outputs
+            this.transactionBuilder = newTxBuilder;
+        })
+
+        return this
+    }
+}