Merge master commit 639a077 into rel/latest

Author: mrdanish26

README.md

@@ -60,8 +60,8 @@ We specifically limit our support to these versions of Node, not because this pa
 
 As each Node LTS version reaches its end-of-life we will exclude that version from the node engines property of our package's package.json file. Removing a Node version is considered a breaking change and will entail the publishing of a new major version of this package. We will not accept any requests to support an end-of-life version of Node, and any pull requests or issues regarding support for an end-of-life version of Node will be closed. We will accept code that allows this package to run on newer, non-LTS, versions of Node. Furthermore, we will attempt to ensure our own changes work on the latest version of Node. To help in that commitment, our continuous integration setup runs the full test suite on the latest release of the following versions of node:
 
-- `18`
 - `20`
+- `22`
 
 JavaScript package managers should allow you to install this package with any version of Node, with, at most, a warning if your version of Node does not fall within the range specified by our node engines property. If you encounter issues installing this package on a supported version of Node, please report the issue to us.
 

examples/ts/ada/adaSplitUtxos.ts

@@ -0,0 +1,133 @@
+/**
+ * ADA UTXO Split Script
+ * Splits UTXOs into 2 ADA outputs (last output may be 1-3 ADA)
+ * Example split transaction: https://preprod.cardanoscan.io/transaction/f7094b57e3729c6fc2908f63be1d8e6ab91af587ae8e8112faea5c74f2e57155?tab=utxo
+ */
+
+import { coins } from '@bitgo/statics';
+import { TransactionBuilderFactory, Transaction } from '@bitgo/sdk-coin-ada';
+import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
+import axios from 'axios';
+
+const CONFIG = {
+  privateKey: '',
+  address: '',
+  denominationAda: 2,
+};
+
+const KOIOS_API = 'https://preprod.koios.rest/api/v1';
+const ADA = 1_000_000;
+
+async function splitUtxos() {
+  // Step 1: Select unspents
+  const { utxos, total } = await selectUnspents();
+  if (!utxos.length) throw new Error('No UTXOs found');
+
+  const numOutputs = Math.floor(Number(total) / ADA / CONFIG.denominationAda);
+  if (numOutputs < 2) throw new Error('Insufficient funds for split');
+
+  // Step 2: Generate transaction
+  const unsignedTx = await generateTransaction(utxos, total);
+
+  // Step 3: Sign transaction
+  const signedTx = signTransaction(unsignedTx);
+
+  // Step 4: Submit transaction
+  await submitTransaction(signedTx);
+}
+
+splitUtxos()
+  .then(() => process.exit(0))
+  .catch((e: Error) => {
+    console.error('Error:', e.message);
+    process.exit(1);
+  });
+
+interface UTXO {
+  tx_hash: string;
+  tx_index: number;
+  value: string;
+}
+
+/**
+ * Step 1: Select unspents
+ * Fetches all UTXOs for the address and calculates total balance
+ */
+async function selectUnspents(): Promise<{ utxos: UTXO[]; total: bigint }> {
+  const response = await axios.post(
+    `${KOIOS_API}/address_info`,
+    { _addresses: [CONFIG.address] },
+    { headers: { 'Content-Type': 'application/json' }, timeout: 30000 }
+  );
+
+  const utxos: UTXO[] = response.data?.[0]?.utxo_set || [];
+  const total = utxos.reduce((sum, u) => sum + BigInt(u.value), BigInt(0));
+
+  console.log(`Step 1: Found ${utxos.length} UTXOs, total ${Number(total) / ADA} ADA`);
+  return { utxos, total };
+}
+
+/**
+ * Step 2: Generate transaction with outputs
+ * Creates (N-1) outputs of exact denomination, last output handled by changeAddress
+ */
+async function generateTransaction(utxos: UTXO[], total: bigint): Promise<Transaction> {
+  const denom = BigInt(CONFIG.denominationAda * ADA);
+  const numOutputs = Math.floor(Number(total) / ADA / CONFIG.denominationAda);
+
+  const factory = new TransactionBuilderFactory(coins.get('tada'));
+  const txBuilder = factory.getTransferBuilder();
+
+  // Add inputs
+  utxos.forEach((u) => txBuilder.input({ transaction_id: u.tx_hash, transaction_index: u.tx_index }));
+
+  // Add (N-1) outputs of exact denomination
+  for (let i = 0; i < numOutputs - 1; i++) {
+    txBuilder.output({ address: CONFIG.address, amount: denom.toString() });
+  } 
+
+  // Last output handled by changeAddress (will be ~1-3 ADA)
+  txBuilder.changeAddress(CONFIG.address, total.toString());
+
+  const tip = await axios.get(`${KOIOS_API}/tip`, { timeout: 30000 });
+  txBuilder.ttl(tip.data[0].abs_slot + 7200);
+
+  const tx = (await txBuilder.build()) as Transaction;
+  console.log(`Step 2: Built tx with ${numOutputs} outputs, fee ${Number(tx.getFee) / ADA} ADA`);
+  return tx;
+}
+
+/**
+ * Step 3: Sign transaction
+ * Signs the transaction with the private key
+ */
+function signTransaction(tx: Transaction): Transaction {
+  const priv = CardanoWasm.PrivateKey.from_bech32(CONFIG.privateKey);
+  const hash = CardanoWasm.hash_transaction(tx.transaction.body());
+
+  const witnessSet = CardanoWasm.TransactionWitnessSet.new();
+  const vkeyWitnesses = CardanoWasm.Vkeywitnesses.new();
+  vkeyWitnesses.add(CardanoWasm.make_vkey_witness(hash, priv));
+  witnessSet.set_vkeys(vkeyWitnesses);
+
+  tx.transaction = CardanoWasm.Transaction.new(tx.transaction.body(), witnessSet, tx.transaction.auxiliary_data());
+
+  console.log(`Step 3: Signed tx ${tx.toJson().id}`);
+  return tx;
+}
+
+/**
+ * Step 4: Submit transaction
+ * Broadcasts the signed transaction to the network
+ */
+async function submitTransaction(tx: Transaction): Promise<void> {
+  const signedTxHex = tx.toBroadcastFormat();
+  const bytes = Uint8Array.from(Buffer.from(signedTxHex, 'hex'));
+
+  await axios.post(`${KOIOS_API}/submittx`, bytes, {
+    headers: { 'Content-Type': 'application/cbor' },
+    timeout: 30000,
+  });
+
+  console.log(`Step 4: https://preprod.cardanoscan.io/transaction/${tx.toJson().id}`);
+}

modules/abstract-lightning/src/lightning/parseWithdrawPsbt.ts

@@ -110,10 +110,15 @@ export function verifyChangeAddress(
       }).address;
       break;
     case 86: // P2TR (Taproot)
-      derivedAddress = utxolib.payments.p2tr({
-        pubkey: derivedPubkey,
-        network,
-      }).address;
+      // P2TR requires x-only pubkey (32 bytes)
+      const xOnlyPubkey = derivedPubkey.length === 33 ? derivedPubkey.subarray(1, 33) : derivedPubkey;
+      derivedAddress = utxolib.payments.p2tr(
+        {
+          pubkey: xOnlyPubkey,
+          network,
+        },
+        { eccLib: utxolib.ecc }
+      ).address;
       break;
     default:
       throw new Error(`Unsupported purpose: ${purpose}`);

modules/abstract-lightning/test/unit/lightning/createPsbt.ts

@@ -0,0 +1,175 @@
+import * as utxolib from '@bitgo/utxo-lib';
+
+export interface PsbtCreationOptions {
+  network: utxolib.Network;
+  inputValue?: number;
+  outputValue?: number;
+  outputAddress?: string;
+  changeValue?: number;
+  changeDerivationPath?: string;
+  changePurpose?: 49 | 84 | 86;
+  includeChangeOutput?: boolean;
+  masterKey?: utxolib.BIP32Interface; // Optional master key for deriving addresses
+}
+
+export interface PsbtCreationResult {
+  psbt: utxolib.Psbt;
+  masterKey: utxolib.BIP32Interface;
+  changeDerivationPath: string;
+  changePurpose: number;
+}
+
+/**
+ * Creates a PSBT for testing purposes with customizable options.
+ * This helper function generates a PSBT with a fake input and configurable outputs.
+ *
+ * @param options - Configuration options for PSBT creation
+ * @returns A constructed PSBT instance and the master key used
+ */
+export function createTestPsbt(options: PsbtCreationOptions): PsbtCreationResult {
+  const {
+    network,
+    inputValue = 500000,
+    outputValue = 100000,
+    outputAddress,
+    changeValue,
+    changeDerivationPath = "m/84'/0'/0'/1/6",
+    changePurpose = 84,
+    includeChangeOutput = true,
+    masterKey,
+  } = options;
+  const fixedSeed = Buffer.from('0101010101010101010101010101010101010101010101010101010101010101', 'hex');
+  const accountMasterKey = masterKey || utxolib.bip32.fromSeed(fixedSeed, network);
+
+  const inputPrivateKey = Buffer.from('0202020202020202020202020202020202020202020202020202020202020202', 'hex');
+  const inputKeyPair = utxolib.ECPair.fromPrivateKey(inputPrivateKey, { network });
+  const p2wpkhInput = utxolib.payments.p2wpkh({
+    pubkey: Buffer.from(inputKeyPair.publicKey),
+    network,
+  });
+
+  // Create a new PSBT instance
+  const psbt = new utxolib.Psbt({ network });
+
+  // Add a fake input to the PSBT
+  const fakeTxId = 'ca6852598b48230ac870814b935b0d982d3968eb00a1d97332dceb6cd9b8505e';
+  const fakeVout = 1;
+
+  psbt.addInput({
+    hash: fakeTxId,
+    index: fakeVout,
+    witnessUtxo: {
+      script: p2wpkhInput.output!,
+      value: BigInt(inputValue),
+    },
+    bip32Derivation: [
+      {
+        masterFingerprint: Buffer.alloc(4, 0),
+        path: "m/84'/0'/0'/0/0",
+        pubkey: Buffer.from(inputKeyPair.publicKey),
+      },
+    ],
+  });
+
+  // Add recipient output
+  let recipientAddress: string;
+  if (outputAddress) {
+    recipientAddress = outputAddress;
+  } else {
+    const recipientPrivateKey = Buffer.from('0303030303030303030303030303030303030303030303030303030303030303', 'hex');
+    const recipientKeyPair = utxolib.ECPair.fromPrivateKey(recipientPrivateKey, { network });
+    // P2TR requires x-only pubkey (32 bytes, without the prefix byte)
+    const xOnlyPubkey =
+      recipientKeyPair.publicKey.length === 33
+        ? recipientKeyPair.publicKey.subarray(1, 33)
+        : recipientKeyPair.publicKey;
+    const recipientP2tr = utxolib.payments.p2tr(
+      {
+        pubkey: xOnlyPubkey,
+        network,
+      },
+      { eccLib: utxolib.ecc }
+    );
+    recipientAddress = recipientP2tr.address!;
+  }
+
+  psbt.addOutput({
+    address: recipientAddress,
+    value: BigInt(outputValue),
+  });
+
+  // Add change output if requested
+  if (includeChangeOutput) {
+    const calculatedChangeValue = changeValue !== undefined ? changeValue : inputValue - outputValue - 10000; // 10k sats fee
+
+    // Parse the derivation path to get the change and address indices
+    // Expected format: m/purpose'/coin_type'/account'/change/address_index
+    const pathSegments = changeDerivationPath.split('/');
+    const changeIndex = Number(pathSegments[pathSegments.length - 2]);
+    const addressIndex = Number(pathSegments[pathSegments.length - 1]);
+
+    // Derive the change key from the master key
+    const changeNode = accountMasterKey.derive(changeIndex).derive(addressIndex);
+    const changePubkey = changeNode.publicKey;
+
+    let changeAddress: string;
+    let changePayment;
+
+    // Create change address based on purpose
+    switch (changePurpose) {
+      case 49: // P2SH-P2WPKH
+        changePayment = utxolib.payments.p2sh({
+          redeem: utxolib.payments.p2wpkh({
+            pubkey: changePubkey,
+            network,
+          }),
+          network,
+        });
+        changeAddress = changePayment.address!;
+        break;
+      case 84: // P2WPKH
+        changePayment = utxolib.payments.p2wpkh({
+          pubkey: changePubkey,
+          network,
+        });
+        changeAddress = changePayment.address!;
+        break;
+      case 86: // P2TR
+        const xOnlyChangePubkey = changePubkey.length === 33 ? changePubkey.subarray(1, 33) : changePubkey;
+        changePayment = utxolib.payments.p2tr(
+          {
+            pubkey: xOnlyChangePubkey,
+            network,
+          },
+          { eccLib: utxolib.ecc }
+        );
+        changeAddress = changePayment.address!;
+        break;
+      default:
+        throw new Error(`Unsupported purpose: ${changePurpose}`);
+    }
+
+    psbt.addOutput({
+      address: changeAddress,
+      value: BigInt(calculatedChangeValue),
+    });
+
+    // Add bip32Derivation to the change output
+    psbt.updateOutput(1, {
+      bip32Derivation: [
+        {
+          masterFingerprint: Buffer.alloc(4, 0),
+          path: changeDerivationPath,
+          pubkey: changePubkey,
+        },
+      ],
+    });
+  }
+
+  return {
+    psbt,
+    masterKey: accountMasterKey,
+    changeDerivationPath,
+    changePurpose,
+  };
+}