feat: partial signing with sendTransaction() with kit (#68)

jonasXchen · GabrielePicco · web-flow · commit b90c711390cf · 2025-10-23T10:20:35.000+08:00
* feat: added solana/kit + adjusted delegate instruction * chore: fixed versioning conflict * fix: linter & CI * refactor: lint fix * fix: workflow automation with kit and web3js * fix: workflow automation with kit and web3js * Release/v0.3.6 (#66) * feat: added solana/kit + adjusted delegate instruction * chore: fixed versioning conflict * fix: linter & CI * refactor: lint fix * fix: workflow automation with kit and web3js * fix: workflow automation with kit and web3js * release: 0.3.6 * release: 0.3.6 --------- Co-authored-by: Gabriele Picco <piccogabriele@gmail.com> * docs: updated links and naming * feat: partial signing for sendTransaction with kit --------- Co-authored-by: Gabriele Picco <piccogabriele@gmail.com>
diff --git a/ts/kit/src/__test__/connection.test.ts b/ts/kit/src/__test__/connection.test.ts
@@ -85,8 +85,10 @@ vi.mock("@solana/kit", () => ({
   partiallySignTransaction: vi.fn(),
   compileTransaction: vi.fn(),
   getBase64EncodedWireTransaction: vi.fn(),
-  pipe: vi.fn((tx, fn) => fn(tx)),
+  isFullySignedTransaction: vi.fn(),
+  assertIsTransactionWithBlockhashLifetime: vi.fn(),
   assertIsTransactionMessageWithBlockhashLifetime: vi.fn(),
+  pipe: vi.fn((tx, fn) => fn(tx)),
   setTransactionMessageLifetimeUsingBlockhash: vi.fn((blockhash, tx) => tx),
 }));
 
@@ -140,6 +142,15 @@ describe("Connection", () => {
       mockSignature,
     );
     vi.mocked(utils.parseCommitsLogsMessage).mockReturnValue(mockSignature);
+    vi.mocked(solanaKit.isFullySignedTransaction).mockImplementation(
+      () => true,
+    );
+    vi.mocked(
+      solanaKit.assertIsTransactionWithBlockhashLifetime,
+    ).mockImplementation(() => {});
+    vi.mocked(
+      solanaKit.assertIsTransactionMessageWithBlockhashLifetime,
+    ).mockImplementation(() => {});
   });
 
   it("should create a Connection instance", async () => {
@@ -177,6 +188,72 @@ describe("Connection", () => {
     expect(sig).toBe(mockSignature);
   });
 
+  it("sendTransaction - fully signed TransactionWithLifetime", async () => {
+    const connection = await Connection.create("http://localhost");
+
+    const fullySignedTx: solanaKit.Transaction &
+      solanaKit.TransactionWithLifetime = {
+      messageBytes: mockTxBytes,
+      signatures: {},
+      lifetimeConstraint: mockLifetimeConstraint,
+    };
+
+    vi.mocked(solanaKit.isFullySignedTransaction).mockImplementation(
+      () => true,
+    );
+
+    const sig = await connection.sendTransaction(fullySignedTx, mockSigners);
+    expect(sig).toBe(mockSignature);
+    expect(solanaKit.isFullySignedTransaction).toHaveBeenCalled();
+  });
+
+  it("sendTransaction - unsigned TransactionWithLifetime", async () => {
+    const connection = await Connection.create("http://localhost");
+
+    const unsignedTx: solanaKit.Transaction &
+      solanaKit.TransactionWithLifetime = {
+      messageBytes: mockTxBytes,
+      signatures: {},
+      lifetimeConstraint: mockLifetimeConstraint,
+    };
+
+    vi.mocked(solanaKit.partiallySignTransaction).mockResolvedValue({
+      messageBytes: mockTxBytes,
+      signatures: {},
+      lifetimeConstraint: mockLifetimeConstraint,
+    });
+
+    const sig = await connection.sendTransaction(unsignedTx, mockSigners);
+
+    expect(sig).toBe(mockSignature);
+    expect(solanaKit.isFullySignedTransaction).toHaveBeenCalled();
+  });
+
+  it("sendTransaction - TransactionMessage without blockhash", async () => {
+    const connection = await Connection.create("http://localhost");
+
+    const txMessage: solanaKit.TransactionMessage &
+      solanaKit.TransactionMessageWithFeePayer<string> = {
+      feePayer: "payer",
+    } as any;
+
+    const prepareSpy = vi
+      .spyOn(connection, "prepareTransactionWithLatestBlockhash")
+      .mockImplementation(async (tx) => ({
+        ...tx,
+        messageBytes: mockTxBytes,
+        signatures: {},
+        lifetimeConstraint: mockLifetimeConstraint,
+      }));
+
+    const sig = await connection.sendTransaction(txMessage, mockSigners);
+
+    expect(sig).toBe(mockSignature);
+    expect(prepareSpy).toHaveBeenCalledWith(txMessage);
+    expect(solanaKit.compileTransaction).toHaveBeenCalled();
+    expect(solanaKit.partiallySignTransaction).toHaveBeenCalled();
+  });
+
   it("should confirmTransaction without errors", async () => {
     const connection = await Connection.create("http://localhost");
     await expect(
@@ -189,11 +266,12 @@ describe("Connection", () => {
 
   it("should partiallySignTransaction", async () => {
     const connection = await Connection.create("http://localhost");
-    const txMessage = {
-      feePayer: "payer",
-      lifetimeConstraint: { blockhash: "bh" },
-    } as unknown as solanaKit.TransactionMessage &
-      solanaKit.TransactionMessageWithFeePayer<string>;
+    const txMessage: solanaKit.Transaction & solanaKit.TransactionWithLifetime =
+      {
+        messageBytes: mockTxBytes,
+        signatures: {},
+        lifetimeConstraint: mockLifetimeConstraint,
+      };
     const partiallySigned = await connection.partiallySignTransaction(
       mockSigners,
       txMessage,
diff --git a/ts/kit/src/connection.ts b/ts/kit/src/connection.ts
@@ -17,8 +17,10 @@ import {
   setTransactionMessageLifetimeUsingBlockhash,
   SolanaRpcApi,
   TransactionWithBlockhashLifetime,
-  TransactionMessageBytes,
-  SignaturesMap,
+  isFullySignedTransaction,
+  Transaction,
+  TransactionWithLifetime,
+  assertIsTransactionWithBlockhashLifetime,
 } from "@solana/kit";
 
 import {
@@ -169,9 +171,9 @@ export class Connection {
    * Sends a transaction message to the network.
    *
    * This method:
-   * 1. Fetches the latest blockhash for the writable accounts.
-   * 2. Sets it as the transaction’s lifetime.
-   * 3. Signs and serializes the transaction.
+   * 1. Fetches the latest blockhash for the writable accounts. (optional)
+   * 2. Sets it as the transaction’s lifetime. (optional)
+   * 3. Signs and serializes the transaction. (optional)
    * 4. Sends it to the cluster.
    *
    * @param transaction - The transaction message to send.
@@ -181,19 +183,15 @@ export class Connection {
    */
   public async sendTransaction(
     transaction:
-      | (TransactionMessage & TransactionMessageWithFeePayer)
-      | Readonly<{
-          messageBytes: TransactionMessageBytes;
-          signatures: SignaturesMap;
-        }>,
+      | Transaction
+      | (Transaction & TransactionWithBlockhashLifetime)
+      | (TransactionMessage & TransactionMessageWithFeePayer),
     signers: CryptoKeyPair[],
-    options?: {
-      skipPreflight?: boolean;
-      preflightCommitment?: Commitment;
-    },
+    options?: { skipPreflight?: boolean; preflightCommitment?: Commitment },
   ): Promise<Signature> {
     const { skipPreflight = true, preflightCommitment = "confirmed" } =
       options ?? {};
+
     const hasBlockhash =
       "lifetimeConstraint" in transaction &&
       typeof transaction.lifetimeConstraint === "object" &&
@@ -202,39 +200,55 @@ export class Connection {
       (transaction.lifetimeConstraint as { blockhash?: unknown }).blockhash !==
         undefined;
 
-    if ("signatures" in transaction && "messageBytes" in transaction) {
-      const serializedTransaction =
-        getBase64EncodedWireTransaction(transaction);
-      const signature = await this.rpc
-        .sendTransaction(serializedTransaction, {
+    const serializeAndSendTransaction = async (tx: Transaction) => {
+      const serialized = getBase64EncodedWireTransaction(tx);
+      return this.rpc
+        .sendTransaction(serialized, {
           encoding: "base64",
           skipPreflight,
           preflightCommitment,
           ...options,
         })
         .send();
-      return signature;
-    } else {
-      if (!hasBlockhash) {
-        transaction =
-          await this.prepareTransactionWithLatestBlockhash(transaction);
+    };
+
+    // Case 1: Already serialized form
+    if ("signatures" in transaction && "messageBytes" in transaction) {
+      const fullySigned = (() => {
+        try {
+          isFullySignedTransaction(transaction);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+
+      if (fullySigned) {
+        return serializeAndSendTransaction(transaction);
       }
+
+      assertIsTransactionWithBlockhashLifetime(transaction);
       const signedTransaction = await this.partiallySignTransaction(
         signers,
         transaction,
       );
-      const serializedTransaction =
-        getBase64EncodedWireTransaction(signedTransaction);
-      const signature = await this.rpc
-        .sendTransaction(serializedTransaction, {
-          encoding: "base64",
-          skipPreflight,
-          preflightCommitment,
-          ...options,
-        })
-        .send();
-      return signature;
+      isFullySignedTransaction(signedTransaction);
+      return serializeAndSendTransaction(signedTransaction);
+    }
+
+    // Case 2: TransactionMessage form
+    if (!hasBlockhash) {
+      transaction =
+        await this.prepareTransactionWithLatestBlockhash(transaction);
     }
+
+    assertIsTransactionMessageWithBlockhashLifetime(transaction);
+    const compiled = compileTransaction(transaction);
+    const signedTransaction = await this.partiallySignTransaction(
+      signers,
+      compiled,
+    );
+    return serializeAndSendTransaction(signedTransaction);
   }
 
   /**
@@ -264,21 +278,11 @@ export class Connection {
    */
   public async partiallySignTransaction(
     signers: CryptoKeyPair[],
-    transaction: TransactionMessage & TransactionMessageWithFeePayer<string>,
-  ): Promise<
-    Readonly<
-      TransactionWithBlockhashLifetime &
-        Readonly<{
-          messageBytes: TransactionMessageBytes;
-          signatures: SignaturesMap;
-        }>
-    >
-  > {
-    assertIsTransactionMessageWithBlockhashLifetime(transaction);
-    const compiledTransaction = compileTransaction(transaction);
+    transaction: Transaction & TransactionWithLifetime,
+  ): Promise<Transaction & TransactionWithLifetime> {
     const signedTransaction = await partiallySignTransaction(
       signers,
-      compiledTransaction,
+      transaction,
     );
     return signedTransaction;
   }
@@ -310,7 +314,7 @@ export class Connection {
    * @returns The latest blockhash and last valid block height.
    */
   public async getLatestBlockhashForTransaction(
-    transaction: TransactionMessage,
+    transaction: TransactionMessage & TransactionMessageWithFeePayer,
   ): Promise<Readonly<LatestBlockhash>> {
     const writableAccounts = getWritableAccounts(transaction);
 
