fix(sdk-coin-ada): unsigned sweep support for WRW with asset list

Ticket: CSHLD-134
Made-with: Cursor

Author: dgm003

modules/sdk-coin-ada/src/ada.ts

@@ -499,21 +499,25 @@ export class Ada extends BaseCoin {
       const transactionPrebuild = { txHex: serializedTx };
       const parsedTx = await this.parseTransaction({ txPrebuild: transactionPrebuild });
       const walletCoin = this.getChain();
-      const output = (parsedTx.outputs as ITransactionRecipient)[0];
+      const txOutputs = unsignedTransaction.toJson().outputs;
+      const output = (parsedTx.outputs as ITransactionRecipient[])[0];
+      // All tokens from the spent UTXOs — shown on the input so WRW can display what is being swept
+      const assetList = Object.values(aggregatedAssetList);
       const inputs = [
         {
           address: senderAddr,
           valueString: output.amount,
-          value: new BigNumber(output.amount).toNumber(),
-        },
-      ];
-      const outputs = [
-        {
-          address: output.address,
-          valueString: output.amount,
-          coinName: walletCoin,
+          value: new BigNumber(output.amount as string).toNumber(),
+          ...(assetList.length > 0 && { assetList }),
         },
       ];
+      // Only attach assetList to outputs that actually carry tokens (have multiAssets)
+      const outputs = (parsedTx.outputs as ITransactionRecipient[]).map((o, i) => ({
+        address: o.address,
+        valueString: o.amount,
+        coinName: walletCoin,
+        ...(txOutputs[i]?.multiAssets && { assetList }),
+      }));
       const spendAmount = output.amount;
       const completedParsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };
       const fee = new BigNumber((parsedTx.fee as { fee: string }).fee);

modules/sdk-coin-ada/test/unit/ada.ts

@@ -674,6 +674,85 @@ describe('ADA', function () {
       should.deepEqual(Number(txJson.outputs[0].amount) + fee, testnetUTXO.UTXO_1.value);
     });
 
+    it('should recover ADA plus token UTXOs - token and ADA both appear in outputs (unsigned sweep)', async function () {
+      callBack
+        .withArgs('address_info', { _addresses: [wrwUser.walletAddress0] })
+        .resolves(endpointResponses.addressInfoResponse.ADAAndTokenUTXOs);
+
+      const res = await basecoin.recover({
+        bitgoKey: wrwUser.bitgoKey,
+        recoveryDestination: destAddr,
+      });
+      res.should.not.be.empty();
+      const unsignedTx = res.txRequests[0].transactions[0].unsignedTx;
+      unsignedTx.should.hasOwnProperty('serializedTx');
+
+      const tx = new Transaction(basecoin);
+      tx.fromRawTransaction(unsignedTx.serializedTx);
+      const txJson = tx.toJson();
+
+      txJson.inputs.length.should.equal(2);
+      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);
+      should.deepEqual(txJson.inputs[1].transaction_id, testnetUTXO.UTXO_TOKEN.tx_hash);
+
+      txJson.outputs.length.should.equal(2);
+
+      const tokenPolicyId = '2533cca6eb42076e144e9f2772c390dece9fce173bc38c72294b3924';
+      const tokenEncodedAssetName = '5741544552';
+      const tokenQuantity = '111';
+      const minADAForToken = 1500000;
+
+      const tokenOutput = txJson.outputs.find((o) => o.multiAssets !== undefined);
+      should.exist(tokenOutput);
+      should.deepEqual(tokenOutput!.address, destAddr);
+      should.deepEqual(Number(tokenOutput!.amount), minADAForToken);
+      const expectedPolicyId = CardanoWasm.ScriptHash.from_bytes(Buffer.from(tokenPolicyId, 'hex'));
+      const expectedAssetName = CardanoWasm.AssetName.new(Buffer.from(tokenEncodedAssetName, 'hex'));
+      (tokenOutput!.multiAssets as CardanoWasm.MultiAsset)
+        .get_asset(expectedPolicyId, expectedAssetName)
+        .to_str()
+        .should.equal(tokenQuantity);
+
+      const adaOutput = txJson.outputs.find((o) => o.multiAssets === undefined);
+      should.exist(adaOutput);
+      should.deepEqual(adaOutput!.address, destAddr);
+      const fee = Number(tx.explainTransaction().fee.fee);
+      const totalBalance = testnetUTXO.UTXO_1.value + testnetUTXO.UTXO_TOKEN.value;
+      should.deepEqual(Number(adaOutput!.amount), totalBalance - minADAForToken - fee);
+
+      const explained = tx.explainTransaction();
+      const explainedTokenOutput = explained.outputs.find((o) => o.amount === minADAForToken.toString());
+      should.exist(explainedTokenOutput);
+
+      // inputs and outputs in parsedTx should carry the assetList from the UTXO directly
+      const parsedTxInputs = res.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs as {
+        address: string;
+        valueString: string;
+        assetList?: { policy_id: string; asset_name: string; quantity: string }[];
+      }[];
+      parsedTxInputs.length.should.equal(1);
+      should.exist(parsedTxInputs[0].assetList);
+      parsedTxInputs[0].assetList!.length.should.equal(1);
+      should.deepEqual(parsedTxInputs[0].assetList![0].policy_id, tokenPolicyId);
+      should.deepEqual(parsedTxInputs[0].assetList![0].asset_name, tokenEncodedAssetName);
+      should.deepEqual(parsedTxInputs[0].assetList![0].quantity, tokenQuantity);
+
+      const parsedTxOutputs = res.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs as {
+        address: string;
+        valueString: string;
+        assetList?: { policy_id: string; asset_name: string; quantity: string }[];
+      }[];
+      const parsedTokenOutput = parsedTxOutputs.find((o) => o.assetList !== undefined);
+      should.exist(parsedTokenOutput);
+      parsedTokenOutput!.assetList!.length.should.equal(1);
+      should.deepEqual(parsedTokenOutput!.assetList![0].policy_id, tokenPolicyId);
+      should.deepEqual(parsedTokenOutput!.assetList![0].asset_name, tokenEncodedAssetName);
+      should.deepEqual(parsedTokenOutput!.assetList![0].quantity, tokenQuantity);
+      // pure ADA output should not have assetList
+      const parsedAdaOutput = parsedTxOutputs.find((o) => o.assetList === undefined);
+      should.exist(parsedAdaOutput);
+    });
+
     it('should recover ADA plus token UTXOs - token and ADA both appear in outputs (signed)', async function () {
       callBack
         .withArgs('address_info', { _addresses: [wrwUser.walletAddress0] })