fix(sdk-coin-xtz): preserve txid when re-parsing signed origination

The previous initFromSerializedTransaction relied on localForger.parse
throwing on signed bytes (unsigned + 64-byte signature) to detect signed
input — but the appended signature bytes are sometimes accidentally
valid Michelson contents, so parse silently succeeds and the txid is
left empty. wallet-platform then fails XTZ wallet creation with
"unable to calculate the id of the deployment transaction" and
"SendQueue validation failed: txid: Path \`txid\` is required"
(COINFLP-116).

Detect signed input by stripping the 64-byte suffix, parsing, and
verifying the parsed result re-forges to those same bytes — a strict
round-trip check rather than relying on parse to throw.

Ticket: COINFLP-116

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: zahin-mohammad

modules/sdk-coin-xtz/src/lib/transaction.ts

@@ -1,10 +1,4 @@
-import {
-  BaseKey,
-  BaseTransaction,
-  InvalidTransactionError,
-  ParseTransactionError,
-  TransactionType,
-} from '@bitgo/sdk-core';
+import { BaseKey, BaseTransaction, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { localForger } from '@taquito/local-forging';
 import { OpKind } from '@taquito/rpc';
@@ -49,22 +43,31 @@ export class Transaction extends BaseTransaction {
    */
   async initFromSerializedTransaction(serializedTransaction: string): Promise<void> {
     this._encodedTransaction = serializedTransaction;
-    try {
-      const parsedTransaction = await localForger.parse(serializedTransaction);
-      await this.initFromParsedTransaction(parsedTransaction);
-    } catch (e) {
-      // If it throws, it is possible the serialized transaction is signed, which is not supported
-      // by local-forging. Try extracting the last 64 bytes and parse it again.
-      const unsignedSerializedTransaction = serializedTransaction.slice(0, -128);
-      const signature = serializedTransaction.slice(-128);
-      if (Utils.isValidSignature(signature)) {
-        throw new ParseTransactionError('Invalid transaction');
+    // A signed Tezos transaction is the unsigned forged bytes with a 64-byte signature
+    // appended (128 hex chars). Detect signed input by checking whether parsing the
+    // bytes with the trailing signature stripped round-trips back to those same bytes;
+    // a successful round-trip is what proves the suffix is a signature, not part of
+    // the operation contents. We cannot rely on `localForger.parse` throwing on a
+    // signed payload — the appended signature bytes are sometimes accidentally valid
+    // operation contents and parse without error, which used to silently drop the
+    // transaction id (COINFLP-116).
+    if (serializedTransaction.length > 128) {
+      const candidateUnsigned = serializedTransaction.slice(0, -128);
+      try {
+        const parsedTransaction = await localForger.parse(candidateUnsigned);
+        const reForged = await localForger.forge(parsedTransaction);
+        if (reForged === candidateUnsigned) {
+          // TODO: encode the signature and save it in _signature
+          const transactionId = await Utils.calculateTransactionId(serializedTransaction);
+          await this.initFromParsedTransaction(parsedTransaction, transactionId);
+          return;
+        }
+      } catch (_) {
+        // fall through to the unsigned-parse path
       }
-      // TODO: encode the signature and save it in _signature
-      const parsedTransaction = await localForger.parse(unsignedSerializedTransaction);
-      const transactionId = await Utils.calculateTransactionId(serializedTransaction);
-      await this.initFromParsedTransaction(parsedTransaction, transactionId);
     }
+    const parsedTransaction = await localForger.parse(serializedTransaction);
+    await this.initFromParsedTransaction(parsedTransaction);
   }
 
   /**

modules/sdk-coin-xtz/test/unit/transaction.ts

@@ -42,6 +42,44 @@ describe('Tezos transaction', function () {
       JSON.stringify(tx.toJson()).should.equal(JSON.stringify(parsedTransaction));
       tx.toBroadcastFormat().should.equal(signedSerializedOriginationTransaction);
     });
+
+    // COINFLP-116: when re-parsing a signed origination transaction whose appended
+    // 64-byte signature happens to be parseable as additional Michelson contents,
+    // localForger.parse does not throw, and the previous implementation skipped
+    // the txid calculation — leaving `_id` empty and breaking address derivation.
+    it('signed transaction whose signature suffix is accidentally parseable', async () => {
+      // Deterministic 16-byte seed (uint32 BE = 174) selects a signing key whose
+      // signature bytes form a valid Michelson tail when appended to the unsigned
+      // transaction. This is the same shape of signed payload produced by
+      // wallet-platform during XTZ wallet initialization.
+      const seed = Buffer.alloc(16);
+      seed.writeUInt32BE(174, 0);
+      const signer = new XtzLib.KeyPair({ seed });
+
+      const signedTx = new XtzLib.Transaction(coins.get('txtz'));
+      await signedTx.initFromSerializedTransaction(unsignedSerializedOriginationTransaction);
+      await signedTx.sign(signer);
+      const signedBytes = signedTx.toBroadcastFormat();
+      const expectedTxId = signedTx.id;
+      expectedTxId.should.match(/^o[a-zA-Z0-9]+$/, 'sanity: signed transaction must have an op-prefixed id');
+
+      // Re-parse the signed transaction the same way wallet-platform does after
+      // signing (txBuilder.from(signedTx).build()).
+      const reparsed = new XtzLib.Transaction(coins.get('txtz'));
+      await reparsed.initFromSerializedTransaction(signedBytes);
+
+      reparsed.id.should.equal(
+        expectedTxId,
+        'transaction id must round-trip through serialization regardless of signature suffix bytes'
+      );
+      // The originated KT1 address is derived from the txid; if the id is empty,
+      // the output address is empty too.
+      reparsed.outputs.length.should.equal(1);
+      reparsed.outputs[0].address.should.startWith(
+        'KT1',
+        'originated address must be derivable when re-parsing a signed transaction'
+      );
+    });
   });
 
   describe('should sign', () => {