Widen signer types (coinbase#502)

Author: GuiBibeau

typescript/packages/x402/src/client/createPaymentHeader.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeAll } from "vitest";
-import { generateKeyPairSigner, type KeyPairSigner } from "@solana/kit";
+import { generateKeyPairSigner, type TransactionSigner } from "@solana/kit";
 import { createPaymentHeader } from "./createPaymentHeader";
 import { PaymentRequirements } from "../types/verify";
 import * as exactSvmClient from "../schemes/exact/svm/client";
@@ -9,7 +9,7 @@ vi.mock("../schemes/exact/svm/client", () => ({
 }));
 
 describe("createPaymentHeader", () => {
-  let svmSigner: KeyPairSigner;
+  let svmSigner: TransactionSigner;
   let paymentRequirements: PaymentRequirements;
 
   beforeAll(async () => {
@@ -85,4 +85,4 @@ describe("createPaymentHeader", () => {
       );
     });
   });
-});
+});

typescript/packages/x402/src/facilitator/facilitator.ts

@@ -15,7 +15,7 @@ import {
   ExactEvmPayload,
 } from "../types/verify";
 import { Chain, Transport, Account } from "viem";
-import { KeyPairSigner } from "@solana/kit";
+import { TransactionSigner } from "@solana/kit";
 
 /**
  * Verifies a payment payload against the required payment details regardless of the scheme
@@ -50,7 +50,12 @@ export async function verify<
 
     // svm
     if (SupportedSVMNetworks.includes(paymentRequirements.network)) {
-      return await verifyExactSvm(client as KeyPairSigner, payload, paymentRequirements, config);
+      return await verifyExactSvm(
+        client as TransactionSigner,
+        payload,
+        paymentRequirements,
+        config,
+      );
     }
   }
 
@@ -93,7 +98,12 @@ export async function settle<transport extends Transport, chain extends Chain>(
 
     // svm
     if (SupportedSVMNetworks.includes(paymentRequirements.network)) {
-      return await settleExactSvm(client as KeyPairSigner, payload, paymentRequirements, config);
+      return await settleExactSvm(
+        client as TransactionSigner,
+        payload,
+        paymentRequirements,
+        config,
+      );
     }
   }
 

typescript/packages/x402/src/schemes/exact/evm/client.test.ts

@@ -166,7 +166,10 @@ describe("signPaymentHeader", () => {
     expect(result.x402Version).toBe(mockUnsignedHeader.x402Version);
     expect(result.scheme).toBe(mockUnsignedHeader.scheme);
     expect(result.network).toBe(mockUnsignedHeader.network);
-    expect(result.payload.authorization).toEqual(mockUnsignedHeader.payload.authorization);
+    expect("authorization" in result.payload).toBe(true);
+    if ("authorization" in result.payload) {
+      expect(result.payload.authorization).toEqual(mockUnsignedHeader.payload.authorization);
+    }
   });
 
   it("should throw an error if signing fails", async () => {

typescript/packages/x402/src/schemes/exact/evm/utils/paymentUtils.test.ts

@@ -17,10 +17,13 @@ const validEvmPayload: ExactEvmPayload = {
 };
 
 // valid evm payment payload
+const defaultEvmNetwork = SupportedEVMNetworks[0] as (typeof SupportedEVMNetworks)[number];
+const defaultSvmNetwork = SupportedSVMNetworks[0] as (typeof SupportedSVMNetworks)[number];
+
 const validEvmPayment: PaymentPayload = {
   x402Version: 1,
   scheme: "exact",
-  network: SupportedEVMNetworks[0],
+  network: defaultEvmNetwork,
   payload: validEvmPayload,
 };
 
@@ -33,7 +36,7 @@ const validSvmPayload: ExactSvmPayload = {
 const validSvmPayment: PaymentPayload = {
   x402Version: 1,
   scheme: "exact",
-  network: SupportedSVMNetworks[0],
+  network: defaultSvmNetwork,
   payload: validSvmPayload,
 };
 
@@ -51,12 +54,18 @@ describe("paymentUtils", () => {
   });
 
   it("throws on invalid network in encodePayment", () => {
-    const invalidPayment = { ...validEvmPayment, network: "invalid-network" };
+    const invalidPayment = {
+      ...validEvmPayment,
+      network: "invalid-network",
+    } as unknown as PaymentPayload;
     expect(() => encodePayment(invalidPayment)).toThrow("Invalid network");
   });
 
   it("throws on invalid network in decodePayment", () => {
-    const invalid = { ...validEvmPayment, network: "invalid-network" };
+    const invalid = {
+      ...validEvmPayment,
+      network: "invalid-network",
+    } as unknown as PaymentPayload;
     const encoded = Buffer.from(JSON.stringify(invalid)).toString("base64");
     expect(() => decodePayment(encoded)).toThrow("Invalid network");
   });

typescript/packages/x402/src/schemes/exact/svm/client.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { afterEach, beforeAll, describe, expect, it, vi, beforeEach } from "vitest";
-import { type Address, type KeyPairSigner, generateKeyPairSigner, lamports } from "@solana/kit";
+import { type Address, type TransactionSigner, generateKeyPairSigner, lamports } from "@solana/kit";
 import * as solanaKit from "@solana/kit";
 import * as token2022 from "@solana-program/token-2022";
 import * as token from "@solana-program/token";
@@ -54,7 +54,7 @@ vi.mock("@solana-program/compute-budget", async importOriginal => {
 });
 
 describe("SVM Client", () => {
-  let clientSigner: KeyPairSigner;
+  let clientSigner: TransactionSigner;
   let paymentRequirements: PaymentRequirements;
   const mockRpcClient = {
     getLatestBlockhash: vi.fn().mockReturnValue({

typescript/packages/x402/src/schemes/exact/svm/client.ts

@@ -9,7 +9,6 @@ import {
   partiallySignTransactionMessageWithSigners,
   prependTransactionMessageInstruction,
   getBase64EncodedWireTransaction,
-  type KeyPairSigner,
   fetchEncodedAccount,
   TransactionSigner,
   Instruction,
@@ -41,7 +40,7 @@ import { getRpcClient } from "../../../shared/svm/rpc";
  * @returns A promise that resolves to a base64 encoded payment header string
  */
 export async function createPaymentHeader(
-  client: KeyPairSigner,
+  client: TransactionSigner,
   x402Version: number,
   paymentRequirements: PaymentRequirements,
   config?: X402Config,
@@ -65,7 +64,7 @@ export async function createPaymentHeader(
  * @returns A promise that resolves to a payment payload containing a base64 encoded solana token transfer tx
  */
 export async function createAndSignPayment(
-  client: KeyPairSigner,
+  client: TransactionSigner,
   x402Version: number,
   paymentRequirements: PaymentRequirements,
   config?: X402Config,
@@ -98,7 +97,7 @@ export async function createAndSignPayment(
  * @returns A promise that resolves to the transaction message with the transfer instruction
  */
 async function createTransferTransactionMessage(
-  client: KeyPairSigner,
+  client: TransactionSigner,
   paymentRequirements: PaymentRequirements,
   config?: X402Config,
 ) {
@@ -150,7 +149,7 @@ async function createTransferTransactionMessage(
  * @returns A promise that resolves to the create ATA (if needed) and transfer instruction
  */
 async function createAtaAndTransferInstructions(
-  client: KeyPairSigner,
+  client: TransactionSigner,
   paymentRequirements: PaymentRequirements,
   config?: X402Config,
 ): Promise<Instruction[]> {
@@ -260,7 +259,7 @@ async function createAtaInstructionOrUndefined(
  * @returns A promise that resolves to the transfer instruction
  */
 async function createTransferInstruction(
-  client: KeyPairSigner,
+  client: TransactionSigner,
   paymentRequirements: PaymentRequirements,
   decimals: number,
   tokenProgramAddress: Address,

typescript/packages/x402/src/schemes/exact/svm/facilitator/settle.test.ts

@@ -1,10 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
-import { type KeyPairSigner, generateKeyPairSigner } from "@solana/kit";
+import { type TransactionSigner, generateKeyPairSigner } from "@solana/kit";
 import * as solanaKit from "@solana/kit";
 import * as transactionConfirmation from "@solana/transaction-confirmation";
 import { PaymentPayload, PaymentRequirements, ExactSvmPayload } from "../../../../types/verify";
-import { decodeTransactionFromPayload, getTokenPayerFromTransaction } from "../../../../shared/svm";
+import {
+  decodeTransactionFromPayload,
+  getTokenPayerFromTransaction,
+  signTransactionWithSigner,
+} from "../../../../shared/svm";
 import { getRpcClient, getRpcSubscriptions } from "../../../../shared/svm/rpc";
 import { verify } from "./verify";
 import * as settleModule from "./settle";
@@ -43,7 +47,7 @@ vi.mock("@solana/transaction-confirmation", async importOriginal => {
 });
 
 describe("SVM Settle", () => {
-  let signer: KeyPairSigner;
+  let signer: TransactionSigner;
   let payerAddress: string;
   let paymentPayload: PaymentPayload;
   let paymentRequirements: PaymentRequirements;
@@ -132,6 +136,7 @@ describe("SVM Settle", () => {
         version: 0,
       } as any);
       vi.mocked(getTokenPayerFromTransaction).mockReturnValue(payerAddress);
+      vi.mocked(signTransactionWithSigner).mockResolvedValue(mockSignedTransaction);
       vi.mocked(transactionConfirmation.waitForRecentTransactionConfirmation).mockResolvedValue(
         undefined,
       );
@@ -142,11 +147,8 @@ describe("SVM Settle", () => {
       // Assert
       expect(verify).toHaveBeenCalledWith(signer, paymentPayload, paymentRequirements, undefined);
       expect(decodeTransactionFromPayload).toHaveBeenCalledWith(paymentPayload.payload);
+      expect(signTransactionWithSigner).toHaveBeenCalledWith(signer, mockSignedTransaction);
       expect(transactionConfirmation.waitForRecentTransactionConfirmation).toHaveBeenCalledOnce();
-      expect(solanaKit.signTransaction).toHaveBeenCalledWith(
-        [signer.keyPair],
-        mockSignedTransaction,
-      );
       expect(mockRpcClient.sendTransaction).toHaveBeenCalled();
       expect(result).toEqual({
         success: true,
@@ -189,6 +191,7 @@ describe("SVM Settle", () => {
       vi.mocked(getTokenPayerFromTransaction).mockReturnValue(payerAddress);
       vi.mocked(getRpcClient).mockReturnValue(mockRpcClient);
       vi.mocked(getRpcSubscriptions).mockReturnValue(mockRpcSubscriptions);
+      vi.mocked(signTransactionWithSigner).mockResolvedValue(mockSignedTransaction);
       // Mock the sendAndConfirmSignedTransaction to throw an error
       vi.mocked(mockRpcClient.sendTransaction).mockReturnValue({
         send: vi.fn().mockRejectedValue(new Error("Unexpected error")),

typescript/packages/x402/src/schemes/exact/svm/facilitator/settle.ts

@@ -14,16 +14,20 @@ import {
   getCompiledTransactionMessageDecoder,
   getSignatureFromTransaction,
   isSolanaError,
-  KeyPairSigner,
+  type Transaction,
+  type TransactionSigner,
   SendTransactionApi,
-  signTransaction,
   SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED,
   SolanaRpcApiDevnet,
   SolanaRpcApiMainnet,
   RpcDevnet,
   RpcMainnet,
 } from "@solana/kit";
-import { decodeTransactionFromPayload, getTokenPayerFromTransaction } from "../../../../shared/svm";
+import {
+  decodeTransactionFromPayload,
+  getTokenPayerFromTransaction,
+  signTransactionWithSigner,
+} from "../../../../shared/svm";
 import { getRpcClient, getRpcSubscriptions } from "../../../../shared/svm/rpc";
 import {
   createBlockHeightExceedencePromiseFactory,
@@ -43,7 +47,7 @@ import { verify } from "./verify";
  * @returns A SettleResponse indicating if the payment is settled and any error reason
  */
 export async function settle(
-  signer: KeyPairSigner,
+  signer: TransactionSigner,
   payload: PaymentPayload,
   paymentRequirements: PaymentRequirements,
   config?: X402Config,
@@ -60,8 +64,9 @@ export async function settle(
 
   const svmPayload = payload.payload as ExactSvmPayload;
   const decodedTransaction = decodeTransactionFromPayload(svmPayload);
-  const signedTransaction = await signTransaction([signer.keyPair], decodedTransaction);
-  const payer = getTokenPayerFromTransaction(decodedTransaction);
+  const signedTransaction = await signTransactionWithSigner(signer, decodedTransaction);
+  assertTransactionFullySigned(signedTransaction);
+  const payer = getTokenPayerFromTransaction(signedTransaction);
 
   const rpc = getRpcClient(paymentRequirements.network, config?.svmConfig?.rpcUrl);
   const rpcSubscriptions = getRpcSubscriptions(
@@ -105,7 +110,7 @@ export async function settle(
  * @returns The signature of the sent transaction
  */
 export async function sendSignedTransaction(
-  signedTransaction: Awaited<ReturnType<typeof signTransaction>>,
+  signedTransaction: Transaction,
   rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>,
   sendTxConfig: Parameters<SendTransactionApi["sendTransaction"]>[1] = {
     skipPreflight: true,
@@ -127,7 +132,7 @@ export async function sendSignedTransaction(
  * @returns The success and signature of the confirmed transaction
  */
 export async function confirmSignedTransaction(
-  signedTransaction: Awaited<ReturnType<typeof signTransaction>>,
+  signedTransaction: Transaction,
   rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>,
   rpcSubscriptions: ReturnType<typeof getRpcSubscriptions>,
 ): Promise<{ success: boolean; errorReason?: (typeof ErrorReasons)[number]; signature: string }> {
@@ -180,7 +185,9 @@ export async function confirmSignedTransaction(
     // wait for the transaction to be confirmed
     await waitForRecentTransactionConfirmation({
       ...config,
-      transaction: signedTransactionWithBlockhashLifetime,
+      transaction: signedTransactionWithBlockhashLifetime as Parameters<
+        typeof waitForRecentTransactionConfirmation
+      >[0]["transaction"],
     });
 
     // return the success and signature
@@ -226,10 +233,25 @@ export async function confirmSignedTransaction(
  * @returns The success and signature of the confirmed transaction
  */
 export async function sendAndConfirmSignedTransaction(
-  signedTransaction: Awaited<ReturnType<typeof signTransaction>>,
+  signedTransaction: Transaction,
   rpc: RpcDevnet<SolanaRpcApiDevnet> | RpcMainnet<SolanaRpcApiMainnet>,
   rpcSubscriptions: ReturnType<typeof getRpcSubscriptions>,
 ): Promise<{ success: boolean; errorReason?: (typeof ErrorReasons)[number]; signature: string }> {
   await sendSignedTransaction(signedTransaction, rpc);
   return await confirmSignedTransaction(signedTransaction, rpc, rpcSubscriptions);
 }
+
+/**
+ * Ensures the provided transaction contains a signature for every required address.
+ *
+ * @param transaction - Transaction to verify for complete signatures
+ */
+function assertTransactionFullySigned(transaction: Transaction): void {
+  const missingAddresses = Object.entries(transaction.signatures)
+    .filter(([, signature]) => signature == null)
+    .map(([address]) => address);
+
+  if (missingAddresses.length > 0) {
+    throw new Error(`transaction_signer_missing_signatures:${missingAddresses.join(",")}`);
+  }
+}

typescript/packages/x402/src/schemes/exact/svm/facilitator/verify.test.ts

@@ -10,7 +10,7 @@ import {
   verifyComputePriceInstruction,
 } from "./verify";
 import {
-  KeyPairSigner,
+  type TransactionSigner,
   assertIsInstructionWithData,
   assertIsInstructionWithAccounts,
   decompileTransactionMessage,
@@ -398,7 +398,7 @@ describe("verify", () => {
   });
 
   describe("verify high level flow", () => {
-    let mockSigner: KeyPairSigner;
+    let mockSigner: TransactionSigner;
     let mockPayerAddress: string;
     let mockPayload: PaymentPayload;
     let mockRequirements: PaymentRequirements;
@@ -814,8 +814,8 @@ describe("verify", () => {
 
     const mockSigner = {
       address: "TestSigner1111111111111111111111111111" as any,
-      keyPair: {} as any,
-    } as KeyPairSigner;
+      signTransactions: vi.fn().mockResolvedValue([{}] as any),
+    } as TransactionSigner;
 
     beforeEach(() => {
       vi.clearAllMocks();

typescript/packages/x402/src/schemes/exact/svm/facilitator/verify.ts

@@ -15,7 +15,7 @@ import {
   decompileTransactionMessage,
   fetchEncodedAccounts,
   getCompiledTransactionMessageDecoder,
-  KeyPairSigner,
+  type TransactionSigner,
   SolanaRpcApiDevnet,
   SolanaRpcApiMainnet,
   RpcDevnet,
@@ -62,7 +62,7 @@ import { SCHEME } from "../../";
  * @returns A VerifyResponse indicating if the payment is valid and any invalidation reason
  */
 export async function verify(
-  signer: KeyPairSigner,
+  signer: TransactionSigner,
   payload: PaymentPayload,
   paymentRequirements: PaymentRequirements,
   config?: X402Config,