@hashgraph/hedera-wallet-connect 2.0.4-canary.5fbc34e.0 → 2.0.4-canary.6b57886.0

package/dist/lib/shared/utils.d.ts

@@ -1,4 +1,4 @@
-import { AccountId, PublicKey, Transaction, LedgerId, Query, SignerSignature } from '@hashgraph/sdk';
+import { AccountId, PublicKey, PrivateKey, Transaction, LedgerId, Query, SignerSignature } from '@hashgraph/sdk';
 import { ProposalTypes, SessionTypes } from '@walletconnect/types';
 import { proto } from '@hashgraph/proto';
 /**
@@ -273,3 +273,35 @@ export declare const accountAndLedgerFromSession: (session: SessionTypes.Struct)
     network: LedgerId;
     account: AccountId;
 }[];
+/**
+ * Adds an additional signature to an already-signed transaction.
+ *
+ * This function is critical for multi-signature workflows where a transaction
+ * has already been signed by one party (e.g., via WalletConnect) and needs
+ * an additional signature from another party (e.g., backend co-signer).
+ *
+ * IMPORTANT: The standard SDK `.sign()` method does NOT work on reconstructed
+ * transactions because it clears the `_transactions` array (Transaction.js:825),
+ * which deletes existing signatures. This function uses proto-level manipulation
+ * to preserve all existing signatures while adding new ones.
+ *
+ * This implementation mirrors the signature merging pattern used in
+ * `DAppSigner.signTransaction()` (DAppSigner.ts:248-273).
+ *
+ * @param transaction - Transaction that already has one or more signatures
+ * @param privateKey - Private key to create additional signature
+ * @returns New transaction instance with all signatures (existing + new)
+ *
+ * @example
+ * ```typescript
+ * // Wallet signs first
+ * const walletSigned = await signer.signTransaction(transaction)
+ *
+ * // Backend adds signature
+ * const fullySigned = await addSignatureToTransaction(walletSigned, backendPrivateKey)
+ *
+ * // Now has both signatures
+ * await fullySigned.execute(client)
+ * ```
+ */
+export declare function addSignatureToTransaction<T extends Transaction>(transaction: T, privateKey: PublicKey | PrivateKey): Promise<T>;

package/dist/lib/shared/utils.js

@@ -18,7 +18,7 @@
  *
  */
 import { Buffer } from 'buffer';
-import { AccountId, Transaction, LedgerId, Query, } from '@hashgraph/sdk';
+import { AccountId, PublicKey, Transaction, LedgerId, Query, } from '@hashgraph/sdk';
 import { proto } from '@hashgraph/proto';
 /**
  * Converts `Transaction` to a Base64-string.
@@ -418,3 +418,93 @@ export const accountAndLedgerFromSession = (session) => {
         };
     });
 };
+/**
+ * Adds an additional signature to an already-signed transaction.
+ *
+ * This function is critical for multi-signature workflows where a transaction
+ * has already been signed by one party (e.g., via WalletConnect) and needs
+ * an additional signature from another party (e.g., backend co-signer).
+ *
+ * IMPORTANT: The standard SDK `.sign()` method does NOT work on reconstructed
+ * transactions because it clears the `_transactions` array (Transaction.js:825),
+ * which deletes existing signatures. This function uses proto-level manipulation
+ * to preserve all existing signatures while adding new ones.
+ *
+ * This implementation mirrors the signature merging pattern used in
+ * `DAppSigner.signTransaction()` (DAppSigner.ts:248-273).
+ *
+ * @param transaction - Transaction that already has one or more signatures
+ * @param privateKey - Private key to create additional signature
+ * @returns New transaction instance with all signatures (existing + new)
+ *
+ * @example
+ * ```typescript
+ * // Wallet signs first
+ * const walletSigned = await signer.signTransaction(transaction)
+ *
+ * // Backend adds signature
+ * const fullySigned = await addSignatureToTransaction(walletSigned, backendPrivateKey)
+ *
+ * // Now has both signatures
+ * await fullySigned.execute(client)
+ * ```
+ */
+export async function addSignatureToTransaction(transaction, privateKey) {
+    // Step 1: Get original transaction bytes (preserves ALL existing signatures)
+    const originalBytes = transaction.toBytes();
+    const originalList = proto.TransactionList.decode(originalBytes);
+    // Step 2: Extract transaction body bytes to sign
+    const firstTransaction = originalList.transactionList[0];
+    let bodyBytes;
+    if (firstTransaction.signedTransactionBytes) {
+        const signedTx = proto.SignedTransaction.decode(firstTransaction.signedTransactionBytes);
+        bodyBytes = signedTx.bodyBytes;
+    }
+    else {
+        bodyBytes = firstTransaction.bodyBytes;
+    }
+    // Step 3: Create signature with the provided private key
+    const publicKey = privateKey instanceof PublicKey ? privateKey : privateKey.publicKey;
+    const signature = privateKey instanceof PublicKey
+        ? (() => {
+            throw new Error('Cannot sign with PublicKey, PrivateKey required');
+        })()
+        : await privateKey.sign(bodyBytes);
+    // Step 4: Add new signature to ALL transactions in the list
+    // Each transaction in the list corresponds to a different node
+    const signedTransactionList = originalList.transactionList.map((tx) => {
+        // Create the new signature pair using SDK's internal method
+        const newSigPair = publicKey._toProtobufSignature(signature);
+        // Check if the transaction has signedTransactionBytes (frozen transactions)
+        if (tx.signedTransactionBytes) {
+            // Decode the SignedTransaction to access the bodyBytes and existing sigMap
+            const signedTx = proto.SignedTransaction.decode(tx.signedTransactionBytes);
+            const existingSigMap = signedTx.sigMap || proto.SignatureMap.create({});
+            // Merge existing signatures with new signature
+            const mergedSigPairs = [...(existingSigMap.sigPair || []), newSigPair];
+            // Create updated SignedTransaction with merged signatures
+            const updatedSignedTx = proto.SignedTransaction.encode({
+                bodyBytes: signedTx.bodyBytes,
+                sigMap: proto.SignatureMap.create({
+                    sigPair: mergedSigPairs,
+                }),
+            }).finish();
+            return {
+                signedTransactionBytes: updatedSignedTx,
+            };
+        }
+        else {
+            // Transaction has bodyBytes and sigMap at the top level (not frozen)
+            const existingSigMap = tx.sigMap || proto.SignatureMap.create({});
+            // Merge existing signatures with new signature
+            const mergedSigPairs = [...(existingSigMap.sigPair || []), newSigPair];
+            return Object.assign(Object.assign({}, tx), { sigMap: Object.assign(Object.assign({}, existingSigMap), { sigPair: mergedSigPairs }) });
+        }
+    });
+    // Step 5: Encode the signed transaction list back to bytes
+    const signedBytes = proto.TransactionList.encode({
+        transactionList: signedTransactionList,
+    }).finish();
+    // Step 6: Return reconstructed transaction with all signatures
+    return Transaction.fromBytes(signedBytes);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "2.0.4-canary.5fbc34e.0",
+  "version": "2.0.4-canary.6b57886.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",