@otoplo/wallet-common 0.1.0

package/src/services/transaction.ts

@@ -0,0 +1,388 @@
+import type { PrivateKey, PublicKey, Script, UTXO } from "libnexa-ts";
+import { Address, AddressType, Transaction, TransactionBuilder, UnitUtils } from "libnexa-ts";
+import type { KeyManager } from "./key";
+import type { RostrumService } from "./rostrum";
+import type { AssetMovement, TransactionDTO, TransactionEntity, TransactionType } from "../types/db.types";
+import { currentTimestamp, isNullOrEmpty, isValidNexaAddress, MAX_INT64, tokenAmountToAssetAmount, tokenIdToHex, VAULT_FIRST_BLOCK } from "../utils/common";
+import type { WalletDB } from "../persistence/wallet-db";
+import type { ITXHistory } from "../types/rostrum.types";
+import type { AddressKey } from "../types/wallet.types";
+
+export interface TxTemplateData {
+  templateScript: Script;
+  constraintScript: Script;
+  visibleArgs: any[];
+  publicKey: PublicKey;
+}
+
+export interface TxOptions {
+  isConsolidate?: boolean;
+  templateData?: TxTemplateData;
+  feeFromAmount?: boolean;
+}
+
+export class TransactionService {
+
+  private readonly rostrumService: RostrumService;
+  private readonly keyManager: KeyManager;
+  private readonly walletDb: WalletDB;
+
+  private readonly MAX_INPUTS_OUTPUTS = 250;
+
+  public constructor(rostrumService: RostrumService, keysManager: KeyManager, walletDb: WalletDB) {
+    this.rostrumService = rostrumService;
+    this.keyManager = keysManager;
+    this.walletDb = walletDb;
+  }
+
+  public async broadcastTransaction(txHex: string): Promise<string> {
+    return this.rostrumService.broadcast(txHex);
+  }
+
+  public async fetchTransactionsHistory(address: string, fromHeight: number): Promise<{txs: ITXHistory[], lastHeight: number}> {
+    let maxHeight = fromHeight;
+    
+    const fromHeightFilter = fromHeight > 0 ? fromHeight + 1 : 0;
+    const txHistory = await this.rostrumService.getTransactionsHistory(address, fromHeightFilter);
+    
+    for (const tx of txHistory) {
+      maxHeight = Math.max(maxHeight, tx.height);
+    }
+    
+    return {txs: txHistory, lastHeight: maxHeight};
+  }
+
+  public async fetchVaultTransactions(address: string): Promise<TransactionDTO[]> {
+    const txHistory = await this.rostrumService.getTransactionsHistory(address, VAULT_FIRST_BLOCK);
+
+    const transactions: Promise<TransactionDTO>[] = [];
+    for (const tx of txHistory) {
+      const txEntry = this.classifyTransaction(tx.tx_hash, [address]);
+      transactions.push(txEntry);
+    }
+
+    return Promise.all(transactions);
+  }
+
+  public async classifyAndSaveTransaction(accountId: number, txHash: string, myAddresses: string[]): Promise<void> {
+    const txDto = await this.classifyTransaction(txHash, myAddresses);
+    txDto.accountId = accountId;
+
+    const txEntity: TransactionEntity = {
+      ...txDto,
+      othersOutputs: JSON.stringify(txDto.othersOutputs),
+      myOutputs: JSON.stringify(txDto.myOutputs),
+      myInputs: JSON.stringify(txDto.myInputs)
+    };
+
+    const involvedAssets = new Set<string>();
+    txDto.myInputs.forEach(m => m.assetId && involvedAssets.add(m.assetId));
+    txDto.myOutputs.forEach(m => m.assetId && involvedAssets.add(m.assetId));
+
+    for (const assetId of involvedAssets) {
+      await this.walletDb.addAssetTransaction({
+        accountId: accountId,
+        assetId: assetId,
+        txIdem: txDto.txIdem,
+        time: txDto.time
+      });
+    }
+    await this.walletDb.addLocalTransaction(txEntity);
+  }
+
+  private async classifyTransaction(txHash: string, myAddresses: string[]): Promise<TransactionDTO> {
+    const t = await this.rostrumService.getTransaction(txHash);
+
+    const myInputs: AssetMovement[] = [];
+    const othersInputs: AssetMovement[] = [];
+    const myOutputs: AssetMovement[] = [];
+    const othersOutputs: AssetMovement[] = [];
+
+    for (const vin of t.vin) {
+      const movement: AssetMovement = {
+        address: vin.addresses[0],
+        nexaAmount: vin.value_satoshi.toString(),
+        assetId: vin.token_id_hex ?? "",
+        assetAmount: tokenAmountToAssetAmount(vin.groupQuantity)
+      };
+      if (myAddresses.includes(movement.address)) {
+        myInputs.push(movement);
+      } else {
+        othersInputs.push(movement);
+      }
+    }
+
+    for (const vout of t.vout) {
+      if (isNullOrEmpty(vout.scriptPubKey.addresses)) continue;
+      const movement: AssetMovement = {
+        address: vout.scriptPubKey.addresses[0],
+        nexaAmount: vout.value_satoshi.toString(),
+        assetId: vout.scriptPubKey.token_id_hex ?? "",
+        assetAmount: tokenAmountToAssetAmount(vout.scriptPubKey.groupQuantity)
+      };
+      if (myAddresses.includes(movement.address)) {
+        myOutputs.push(movement);
+      } else {
+        othersOutputs.push(movement);
+      }
+    }
+
+    let type: TransactionType;
+    if (myInputs.length === 0) {
+      type = 'receive';
+    } else if (myOutputs.length === 0) {
+      type = 'send';
+    } else if (othersInputs.length === 0 && othersOutputs.length === 0) {
+      type = 'self';
+    } else if (othersInputs.length === 0 && othersOutputs.length > 0) {
+      type = 'send';
+    } else if (othersInputs.length > 0 && othersOutputs.length === 0) {
+      type = 'receive';
+    } else {
+      type = 'swap';
+    }
+
+    const isConfirmed = t.height > 0;
+    const txDto: TransactionDTO = {
+      accountId: 0, // Will be set in classifyAndSaveTransaction
+      txId: t.txid,
+      txIdem: t.txidem,
+      time: isConfirmed ? t.time : currentTimestamp(),
+      height: isConfirmed ? t.height : 0,
+      type: type,
+      fee: t.fee_satoshi.toString(),
+      othersOutputs: type == 'send' || type == 'swap' ? othersOutputs : [],
+      myOutputs: myOutputs,
+      myInputs: myInputs
+    };
+
+    return txDto;
+  }
+
+  public async buildAndSignTransferTransaction(
+    from: AddressKey[],
+    toAddr: string,
+    toChange: string,
+    amount: string,
+    feeFromAmount?: boolean,
+    token?: string,
+    feePerByte?: number,
+    data?: string
+  ): Promise<Transaction> {
+    const txOptions: TxOptions = {
+      feeFromAmount: feeFromAmount
+    }
+    
+    const txBuilder = this.prepareTransaction(toAddr, amount, token, data);
+    if (feePerByte) {
+      txBuilder.feePerByte(feePerByte);
+    }
+
+    let tokenPrivKeys = new Map<string, PrivateKey>();
+    if (token) {
+      tokenPrivKeys = await this.populateTokenInputsAndChange(txBuilder, from, toChange, token, BigInt(amount));
+    }
+    const privKeys = await this.populateNexaInputsAndChange(txBuilder, from, toChange, txOptions);
+    tokenPrivKeys.forEach((v, k) => privKeys.set(k, v));
+
+    return await this.finalizeTransaction(txBuilder, Array.from(privKeys.values()));
+  }
+
+  public async buildAndSignConsolidateTransaction(from: AddressKey[], toChange: string, templateData?: TxTemplateData): Promise<Transaction> {
+    const txOptions: TxOptions = {
+      isConsolidate: true,
+      templateData: templateData
+    }
+    
+    const txBuilder = new TransactionBuilder();
+    const privKeys = await this.populateNexaInputsAndChange(txBuilder, from, toChange, txOptions);
+    
+    return this.finalizeTransaction(txBuilder, Array.from(privKeys.values()));
+  }
+
+  private prepareTransaction(toAddr: string, amount: string, token?: string, data?: string): TransactionBuilder {
+    if (!isValidNexaAddress(toAddr) && !isValidNexaAddress(toAddr, AddressType.PayToPublicKeyHash)) {
+      throw new Error('Invalid Address.');
+    }
+    if ((token && BigInt(amount) < 1n) || (!token && parseInt(amount) < Transaction.DUST_AMOUNT)) {
+      throw new Error("The amount is too low.");
+    }
+    if ((token && BigInt(amount) > MAX_INT64) || (!token && parseInt(amount) > Transaction.MAX_MONEY)) {
+      throw new Error("The amount is too high.");
+    }
+    
+    const builder = new TransactionBuilder();
+    if (data) {
+      builder.addData(data);
+    }
+
+    if (token) {
+      if (!isValidNexaAddress(token, AddressType.GroupIdAddress)) {
+        throw new Error('Invalid Token ID');
+      }
+      if (Address.getOutputType(toAddr) === 0) {
+        throw new Error('Token must be sent to script template address');
+      }
+      builder.to(toAddr, Transaction.DUST_AMOUNT, token, BigInt(amount))
+    } else {
+      builder.to(toAddr, amount);
+    }
+    
+    return builder;
+  }
+
+  private async populateNexaInputsAndChange(txBuilder: TransactionBuilder, from: AddressKey[], toChange: string, options: TxOptions): Promise<Map<string, PrivateKey>> {
+    const allKeys = from.filter(k => BigInt(k.balance.confirmed) + BigInt(k.balance.unconfirmed) > 0n);
+    if (isNullOrEmpty(allKeys)) {
+      throw new Error("Not enough Nexa balance.");
+    }
+    
+    const usedKeys = new Map<string, PrivateKey>();
+    const origAmount = options.isConsolidate ? 0 : Number(txBuilder.transaction.outputs.find(out => out.value > 0n)!.value);
+    
+    for (const key of allKeys) {
+      const utxos = await this.rostrumService.getNexaUtxos(key.address);
+      for (const utxo of utxos) {
+        const input: UTXO = {
+          outpoint: utxo.outpoint_hash,
+          address: key.address,
+          satoshis: utxo.value,
+          templateData: options.templateData
+        }
+        txBuilder.from(input);
+        
+        if (!usedKeys.has(key.address)) {
+          const hdkey = this.keyManager.getKey(key.keyPath);
+          usedKeys.set(key.address, hdkey.privateKey);
+        }
+        
+        if (options.isConsolidate) {
+          txBuilder.change(toChange);
+          if (txBuilder.transaction.inputs.length > this.MAX_INPUTS_OUTPUTS) {
+            return usedKeys;
+          }
+        } else {
+          const tx = txBuilder.transaction;
+          if (tx.inputs.length > this.MAX_INPUTS_OUTPUTS) {
+            throw new Error("Too many inputs. Consider consolidate transactions or reduce the send amount.");
+          }
+          
+          const unspent = tx.getUnspentValue();
+          if (unspent < 0n) {
+            continue;
+          }
+          
+          if (unspent == 0n && options.feeFromAmount) {
+            const txFee = tx.estimateRequiredFee();
+            tx.updateOutputAmount(0, origAmount - txFee);
+            return usedKeys;
+          }
+          
+          txBuilder.change(toChange);
+          if (options.feeFromAmount) {
+            const hasChange = tx.getChangeOutput();
+            let txFee = tx.estimateRequiredFee();
+            tx.updateOutputAmount(0, origAmount - txFee);
+            
+            // edge case where change added after update
+            if (!hasChange && tx.getChangeOutput()) {
+              txFee = tx.estimateRequiredFee();
+              tx.updateOutputAmount(0, origAmount - txFee);
+            }
+          }
+          
+          // check again after change output manipulation
+          if (tx.getUnspentValue() < tx.estimateRequiredFee()) {
+            // try to add more utxos to satisfy the minimum fee
+            continue;
+          }
+          
+          return usedKeys;
+        }
+      }
+    }
+    
+    if (options.isConsolidate) {
+      if (usedKeys.size > 0) {
+        return usedKeys;
+      }
+      throw new Error("Not enough Nexa balance.");
+    }
+    
+    const err = {
+      errorMsg: "Not enough Nexa balance.",
+      amount: UnitUtils.formatNEXA(txBuilder.transaction.outputs[0].value),
+      fee: UnitUtils.formatNEXA(txBuilder.transaction.estimateRequiredFee())
+    }
+    
+    throw new Error(JSON.stringify(err));
+  }
+
+  private async populateTokenInputsAndChange(txBuilder: TransactionBuilder, from: AddressKey[], toChange: string, token: string, outTokenAmount: bigint): Promise<Map<string, PrivateKey>> {
+    const tokenHex = tokenIdToHex(token);
+    const allKeys = from.filter(k => Object.keys(k.tokensBalance).includes(tokenHex));
+    
+    if (isNullOrEmpty(allKeys)) {
+      throw new Error("Not enough token balance.");
+    }
+    
+    const usedKeys = new Map<string, PrivateKey>();
+    let inTokenAmount = 0n;
+    
+    for (const key of allKeys) {
+      const utxos = await this.rostrumService.getTokenUtxos(key.address, token);
+      for (const utxo of utxos) {
+        if (BigInt(utxo.token_amount) < 0n) {
+          continue;
+        }
+        txBuilder.from({
+          outpoint: utxo.outpoint_hash,
+          address: key.address,
+          satoshis: utxo.value,
+          groupId: utxo.group,
+          groupAmount: BigInt(utxo.token_amount),
+        });
+        
+        inTokenAmount = inTokenAmount + BigInt(utxo.token_amount);
+        if (!usedKeys.has(key.address)) {
+          const hdkey = this.keyManager.getKey(key.keyPath);
+          usedKeys.set(key.address, hdkey.privateKey);
+        }
+        
+        if (inTokenAmount > MAX_INT64) {
+          throw new Error("Token inputs exceeded max amount. Consider sending in small chunks");
+        }
+        if (txBuilder.transaction.inputs.length > this.MAX_INPUTS_OUTPUTS) {
+          throw new Error("Too many inputs. Consider consolidating transactions or reduce the send amount.");
+        }
+        
+        if (inTokenAmount == outTokenAmount) {
+          return usedKeys;
+        }
+        if (inTokenAmount > outTokenAmount) {
+          // change
+          txBuilder.to(toChange, Transaction.DUST_AMOUNT, token, inTokenAmount - outTokenAmount);
+          return usedKeys;
+        }
+      }
+    }
+    
+    throw new Error("Not enough token balance");
+  }
+
+  private async finalizeTransaction(tx: TransactionBuilder, privKeys: PrivateKey[]): Promise<Transaction> {
+    const tip = await this.rostrumService.getBlockTip();
+    return tx.lockUntilBlockHeight(tip.height).sign(privKeys).build();
+  }
+
+  public printTransactionJson(tx?: Transaction | null): string {
+    if (!tx) {
+      return "";
+    }
+    const obj = {
+      ...tx.toObject(),
+      hex: tx.toString(),
+    }
+    return JSON.stringify(obj, null, 2)
+  }
+}

package/src/services/tx-transformer.ts

@@ -0,0 +1,244 @@
+import type { Input, PrivateKey} from "libnexa-ts";
+import { BufferUtils, Hash, Opcode, Output, OutputSighashType, Script, ScriptFactory, SighashType, Transaction, TxSigner } from "libnexa-ts";
+import type { KeyManager } from "./key";
+import type { RostrumService } from "./rostrum";
+import type { AddressKey, AssetMovement, MovementDetails, TransactionDetails } from "../types";
+import { tokenAmountToAssetAmount, tokenIdToHex } from "../utils";
+import type { AssetService } from "./asset";
+
+interface TransactionContext {
+  address: string;
+  privateKey: PrivateKey;
+  txDetails: TransactionDetails;
+  myInputs: Map<number, AssetMovement>;
+  myOutputs: Map<number, AssetMovement>;
+  involvedAssets: Set<string>;
+  inputsToSign: Set<number>;
+  coveredOutputs: Set<number>;
+  allMyOutputsCovered: boolean;
+}
+
+export class TransactionTransformer {
+
+  private readonly rostrumService: RostrumService;
+  private readonly keyManager: KeyManager;
+  private readonly assetService: AssetService;
+
+  public constructor(rostrumService: RostrumService, keyManager: KeyManager, assetService: AssetService) {
+    this.rostrumService = rostrumService;
+    this.keyManager = keyManager;
+    this.assetService = assetService;
+  }
+
+  public async transformRawTransaction(hex: string, addressKey: AddressKey): Promise<TransactionDetails> {
+    const context = this.createContext(hex, addressKey);
+
+    await this.processInputs(context);
+    this.processOutputs(context);
+    this.signInputs(context);
+    await this.processAssetMovements(context);
+
+    return context.txDetails;
+  }
+
+  private createContext(hex: string, addressKey: AddressKey): TransactionContext {
+    try {
+      return {
+        address: addressKey.address,
+        privateKey: this.keyManager.getKey(addressKey.keyPath).privateKey,
+        txDetails: {
+          tx: new Transaction(hex),
+          send: [],
+          receive: []
+        },
+        myInputs: new Map<number, AssetMovement>(),
+        myOutputs: new Map<number, AssetMovement>(),
+        involvedAssets: new Set<string>(),
+        inputsToSign: new Set<number>(),
+        coveredOutputs: new Set<number>(),
+        allMyOutputsCovered: false,
+      };
+    } catch {
+      throw new Error("Invalid transaction format.");
+    }
+  }
+
+  private async processInputs(context: TransactionContext): Promise<void> {
+    const promises = [];
+    for (let i = 0; i < context.txDetails.tx.inputs.length; i++) {
+      const p = this.processInput(context, i);
+      promises.push(p);
+    }
+    await Promise.all(promises);
+  }
+
+  private async processInput(context: TransactionContext, index: number): Promise<void> {
+    const input = context.txDetails.tx.inputs[index];
+    const utxo = await this.rostrumService.getUtxo(BufferUtils.bufferToHex(input.outpoint));
+    if (utxo.status == "spent") {
+      throw new Error("Input UTXO is already spent.");
+    }
+
+    input.output = new Output(utxo.amount, utxo.scriptpubkey);
+    if (input.output.address == context.address) {
+      const assetId = utxo.token_id_hex || "NEXA";
+      context.myInputs.set(index, {
+        address: context.address,
+        nexaAmount: utxo.amount.toString(),
+        assetId: assetId,
+        assetAmount: tokenAmountToAssetAmount(utxo.group_quantity) || utxo.amount.toString()
+      });
+      context.involvedAssets.add(assetId);
+      
+      if (input.scriptSig.isEmpty()) {
+        context.inputsToSign.add(index);
+      }
+    }
+
+    if (input.scriptSig.findPlaceholder() > 0) {
+      context.inputsToSign.add(index);
+    }
+  }
+
+  private processOutputs(context: TransactionContext): void {
+    for (let i = 0; i < context.txDetails.tx.outputs.length; i++) {
+      const output = context.txDetails.tx.outputs[i].toObject();
+      if (output.address !== context.address) {
+        continue;
+      }
+
+      const assetId = output.groupId ? tokenIdToHex(output.groupId) : "NEXA";
+      const movement = {
+        address: output.address,
+        nexaAmount: output.value.toString(),
+        assetId: assetId,
+        assetAmount: tokenAmountToAssetAmount(output.groupAmount) || output.value.toString()
+      };
+
+      context.involvedAssets.add(assetId);
+      context.myOutputs.set(i, movement);
+    }
+  }
+
+  private signInputs(context: TransactionContext): void {
+    if (context.inputsToSign.size == 0) {
+      throw new Error("No inputs to sign.");
+    }
+
+    for (const index of context.inputsToSign) {
+      const input = context.txDetails.tx.inputs[index];
+      const subscript = this.validateAndGetSubscript(input);
+
+      if (input.scriptSig.isEmpty()) { // only p2pkt can be empty
+        context.allMyOutputsCovered = true;
+        const txSig = TxSigner.sign(context.txDetails.tx, index, SighashType.ALL, subscript, context.privateKey).toTxFormat();
+        const constraint = Script.empty().add(context.privateKey.publicKey.toBuffer());
+        input.scriptSig = ScriptFactory.buildScriptTemplateIn(undefined, constraint, Script.empty().add(txSig))
+      } else {
+        const placeholderIndex = input.scriptSig.findPlaceholder();
+        const placeholder = input.scriptSig.chunks[placeholderIndex];
+        const sigHashBuf = placeholder.buf!.subarray(64);
+        const sigHashType = SighashType.fromBuffer(sigHashBuf);
+        this.processSignatureCoverage(context, sigHashType);
+
+        const txSig = TxSigner.sign(context.txDetails.tx, index, sigHashType, subscript, context.privateKey).toTxFormat(sigHashBuf);
+        input.scriptSig.replaceChunk(placeholderIndex, Script.empty().add(txSig));
+      }
+    }
+
+    if (!context.allMyOutputsCovered) {
+      throw new Error("Some of interested outputs are not covered by signatures.");
+    }
+  }
+
+  private validateAndGetSubscript(input: Input): Script {
+    if (input.output!.scriptPubKey.isPublicKeyTemplateOut()) {
+      if (input.scriptSig.isEmpty() || input.scriptSig.isPublicKeyTemplateIn()) {
+        return Script.empty().add(Opcode.OP_FROMALTSTACK).add(Opcode.OP_CHECKSIGVERIFY);
+      }
+      throw new Error("Invalid input script type.");
+    }
+    
+    if (input.output!.scriptPubKey.isScriptTemplateOut()) {
+      if (!input.scriptSig.isScriptTemplateIn()) {
+        throw new Error("Unsupported input script type.");
+      }
+
+      const templateHash = input.output!.scriptPubKey.getTemplateHash() as Uint8Array;
+      const templateBuf = input.scriptSig.chunks[0].buf!;
+      if (BufferUtils.equals(templateHash, Hash.sha256ripemd160(templateBuf)) || BufferUtils.equals(templateHash, Hash.sha256sha256(templateBuf))) {
+        return Script.fromBuffer(templateBuf);
+      }
+
+      throw new Error("Invalid input script template.");
+    }
+    
+    throw new Error("Unsupported prevout script type.");
+  }
+
+  private processSignatureCoverage(context: TransactionContext, sigHashType: SighashType): void {
+    if (context.allMyOutputsCovered) {
+      return;
+    }
+
+    if (sigHashType.outType == OutputSighashType.TWO) {
+      context.coveredOutputs.add(sigHashType.outData[0]);
+      context.coveredOutputs.add(sigHashType.outData[1]);
+      this.checkSignatureCoverage(context);
+    } else if (sigHashType.outType == OutputSighashType.FIRSTN) {
+      const n = sigHashType.outData[0];
+      for (let i = 0; i < n; i++) {
+        context.coveredOutputs.add(i);
+      }
+      this.checkSignatureCoverage(context);
+    } else {
+      context.allMyOutputsCovered = true;
+    }
+  }
+
+  private checkSignatureCoverage(context: TransactionContext): void {
+    if (context.allMyOutputsCovered) {
+      return;
+    }
+
+    for (const i of context.myOutputs.keys()) {
+      if (!context.coveredOutputs.has(i)) {
+        return;
+      }
+    }
+    context.allMyOutputsCovered = true;
+  }
+
+  private async processAssetMovements(context: TransactionContext): Promise<void> {
+    const myInputs = Array.from(context.myInputs.values());
+    const myOutputs = Array.from(context.myOutputs.values());
+
+    const promises = [];
+    for (const assetId of context.involvedAssets) {
+      const p = this.processAssetMovement(context, assetId, myInputs, myOutputs);
+      promises.push(p);
+    }
+    await Promise.all(promises);
+  }
+
+  private async processAssetMovement(context: TransactionContext, assetId: string, myInputs: AssetMovement[], myOutputs: AssetMovement[]): Promise<void> {
+    const sentAmount = myInputs
+      .reduce((sum, m) => m.assetId === assetId ? sum + BigInt(m.assetAmount) : sum, 0n);
+
+    const receivedAmount = myOutputs
+      .reduce((sum, m) => m.assetId === assetId ? sum + BigInt(m.assetAmount) : sum, 0n);
+
+    if (sentAmount > 0n || receivedAmount > 0n) {
+      const movement: MovementDetails = { amount: receivedAmount - sentAmount };
+      if (assetId !== "NEXA") {
+        movement.asset = await this.assetService.getAssetInfo(assetId);
+      }
+
+      if (movement.amount > 0n) {
+        context.txDetails.receive.push(movement);
+      } else if (movement.amount < 0n) {
+        context.txDetails.send.push(movement);
+      }
+    }
+  }
+}