@alchemy/wallet-apis 5.0.0-beta.3 → 5.0.0-beta.31

package/src/actions/solana/prepareCalls.ts

@@ -0,0 +1,120 @@
+import type { Prettify } from "viem";
+import type {
+  DistributiveOmit,
+  InnerSolanaWalletApiClient,
+} from "../../types.js";
+import { isSolanaChain } from "../../utils/assertions.js";
+import type { SolanaChainId } from "@alchemy/wallet-api-types";
+import { SolanaPrepareCallsParams as SolanaPrepareCallsSchema } from "@alchemy/wallet-api-types";
+import { wallet_prepareCalls as MethodSchema } from "@alchemy/wallet-api-types/rpc";
+import type { z } from "zod";
+import { BaseError } from "@alchemy/common";
+import { LOGGER } from "../../logger.js";
+import {
+  mergeSolanaClientCapabilities,
+  type WithCapabilities,
+} from "../../utils/capabilities.js";
+import {
+  methodSchema,
+  encode,
+  decode,
+  type MethodResponse,
+} from "../../utils/schema.js";
+
+const schema = methodSchema(MethodSchema);
+type PrepareCallsResponse = MethodResponse<typeof MethodSchema>;
+
+type BaseSolanaPrepareCallsParams = z.output<typeof SolanaPrepareCallsSchema>;
+
+export type SolanaPrepareCallsParams = Prettify<
+  WithCapabilities<
+    DistributiveOmit<BaseSolanaPrepareCallsParams, "from" | "chainId"> & {
+      account?: string;
+      chainId?: SolanaChainId;
+    }
+  >
+>;
+
+type SolanaPrepareCallsResponse = Extract<
+  PrepareCallsResponse,
+  { type: "solana-transaction-v0" }
+>;
+
+function isSolanaResponse(
+  response: PrepareCallsResponse,
+): response is SolanaPrepareCallsResponse {
+  return response.type === "solana-transaction-v0";
+}
+
+export type SolanaPrepareCallsResult = SolanaPrepareCallsResponse;
+
+/**
+ * Prepares Solana instructions for execution by building a versioned transaction.
+ * Returns the compiled transaction and a signature request that needs to be signed
+ * before submitting to sendPreparedCalls.
+ *
+ * @param {InnerSolanaWalletApiClient} client - The Solana wallet API client
+ * @param {SolanaPrepareCallsParams} params - Parameters for preparing Solana calls
+ * @param {Array<{programId: string, accounts?: Array, data: Hex}>} params.calls - Array of Solana instructions
+ * @param {string} [params.account] - The Solana address to execute from. Defaults to the signer's address.
+ * @param {SolanaChainId} [params.chainId] - The Solana chain ID. Defaults to the client's chain.
+ * @param {object} [params.capabilities] - Optional capabilities (e.g. paymaster sponsorship)
+ * @returns {Promise<SolanaPrepareCallsResult>} The prepared Solana transaction with signature request
+ *
+ * @example
+ * ```ts
+ * const result = await client.prepareCalls({
+ *   calls: [{
+ *     programId: "11111111111111111111111111111111",
+ *     data: "0x...",
+ *   }],
+ *   capabilities: {
+ *     paymaster: { policyId: "your-policy-id" }
+ *   }
+ * });
+ * ```
+ */
+export async function prepareCalls(
+  client: InnerSolanaWalletApiClient,
+  params: SolanaPrepareCallsParams,
+): Promise<SolanaPrepareCallsResult> {
+  const { account, chainId, capabilities: caps, ...rest } = params;
+  const from = account ?? client.solanaAccount;
+  if (!isSolanaChain(client.chain)) {
+    throw new BaseError("Expected a Solana chain on the client");
+  }
+  const resolvedChainId = chainId ?? client.chain.solanaChainId;
+
+  const merged = mergeSolanaClientCapabilities(client, caps);
+  const capabilities = merged?.paymaster
+    ? { paymasterService: merged.paymaster }
+    : undefined;
+
+  LOGGER.debug("solana:prepareCalls:start", {
+    callsCount: params.calls?.length,
+    hasCapabilities: !!caps,
+  });
+
+  const rpcParams = encode(SolanaPrepareCallsSchema, {
+    ...rest,
+    chainId: resolvedChainId,
+    from,
+    capabilities,
+  });
+
+  const rpcResp = await client.request({
+    method: "wallet_prepareCalls",
+    params: [rpcParams],
+  });
+
+  LOGGER.debug("solana:prepareCalls:done");
+  const decoded = decode(schema.response, rpcResp);
+
+  if (!isSolanaResponse(decoded)) {
+    throw new BaseError(
+      `Unexpected EVM response from Solana prepareCalls: ${decoded.type}`,
+    );
+  }
+
+  return decoded;
+}

package/src/actions/solana/sendCalls.ts

@@ -0,0 +1,66 @@
+import type { Prettify } from "viem";
+import type {
+  DistributiveOmit,
+  InnerSolanaWalletApiClient,
+} from "../../types.js";
+import type { SolanaChainId } from "@alchemy/wallet-api-types";
+import { prepareCalls, type SolanaPrepareCallsParams } from "./prepareCalls.js";
+import { signPreparedCalls } from "./signPreparedCalls.js";
+import {
+  sendPreparedCalls,
+  type SolanaSendPreparedCallsResult,
+} from "./sendPreparedCalls.js";
+import { LOGGER } from "../../logger.js";
+
+export type SolanaSendCallsParams = Prettify<
+  DistributiveOmit<SolanaPrepareCallsParams, "chainId"> & {
+    chainId?: SolanaChainId;
+  }
+>;
+
+export type SolanaSendCallsResult = Prettify<SolanaSendPreparedCallsResult>;
+
+/**
+ * Prepares, signs, and submits Solana instructions in a single call.
+ * Internally calls `prepareCalls`, `signPreparedCalls`, and `sendPreparedCalls`.
+ *
+ * @param {InnerSolanaWalletApiClient} client - The Solana wallet API client
+ * @param {SolanaSendCallsParams} params - Parameters for sending Solana calls
+ * @param {Array<{programId: string, accounts?: Array, data: Hex}>} params.calls - Array of Solana instructions
+ * @param {string} [params.account] - The Solana address to execute from. Defaults to the signer's address.
+ * @param {object} [params.capabilities] - Optional capabilities (e.g. paymaster sponsorship)
+ * @returns {Promise<SolanaSendCallsResult>} The result containing the call ID
+ *
+ * @example
+ * ```ts
+ * const result = await client.sendCalls({
+ *   calls: [{
+ *     programId: "11111111111111111111111111111111",
+ *     data: "0x...",
+ *   }],
+ *   capabilities: {
+ *     paymaster: { policyId: "your-policy-id" }
+ *   }
+ * });
+ * ```
+ */
+export async function sendCalls(
+  client: InnerSolanaWalletApiClient,
+  params: SolanaSendCallsParams,
+): Promise<SolanaSendCallsResult> {
+  LOGGER.info("solana:sendCalls:start", {
+    calls: params.calls?.length,
+    hasCapabilities: !!params.capabilities,
+  });
+
+  const { chainId, ...rest } = params;
+  const prepared = await prepareCalls(client, {
+    ...rest,
+    ...(chainId != null ? { chainId } : {}),
+  });
+
+  const signed = await signPreparedCalls(client, prepared);
+  const res = await sendPreparedCalls(client, signed);
+  LOGGER.info("solana:sendCalls:done");
+  return res;
+}

package/src/actions/solana/sendPreparedCalls.ts

@@ -0,0 +1,65 @@
+import type { Prettify } from "viem";
+import type { InnerSolanaWalletApiClient } from "../../types.js";
+import { PreparedCall_SolanaV0_Signed as PreparedCall_SolanaV0_SignedSchema } from "@alchemy/wallet-api-types";
+import type { z } from "zod";
+import { BaseError } from "@alchemy/common";
+import { LOGGER } from "../../logger.js";
+import { wallet_sendPreparedCalls as MethodSchema } from "@alchemy/wallet-api-types/rpc";
+import {
+  methodSchema,
+  encode,
+  decode,
+  type MethodResponse,
+} from "../../utils/schema.js";
+
+const schema = methodSchema(MethodSchema);
+type SendPreparedCallsResponse = MethodResponse<typeof MethodSchema>;
+
+export type SolanaSendPreparedCallsParams = Prettify<
+  z.output<typeof PreparedCall_SolanaV0_SignedSchema>
+>;
+
+type SolanaSendPreparedCallsResponse = Extract<
+  SendPreparedCallsResponse,
+  { details: { type: "solana-transaction-v0" } }
+>;
+
+export type SolanaSendPreparedCallsResult = SolanaSendPreparedCallsResponse;
+
+function isSolanaResponse(
+  response: SendPreparedCallsResponse,
+): response is SolanaSendPreparedCallsResult {
+  return response.details.type === "solana-transaction-v0";
+}
+
+/**
+ * Sends a signed Solana transaction.
+ * This method is used after signing the signature request returned from prepareCalls.
+ *
+ * @param {InnerSolanaWalletApiClient} client - The Solana wallet API client
+ * @param {SolanaSendPreparedCallsParams} params - The signed Solana transaction
+ * @returns {Promise<SolanaSendPreparedCallsResult>} The result containing the call ID
+ */
+export async function sendPreparedCalls(
+  client: InnerSolanaWalletApiClient,
+  params: SolanaSendPreparedCallsParams,
+): Promise<SolanaSendPreparedCallsResult> {
+  LOGGER.debug("solana:sendPreparedCalls:start", { type: params.type });
+
+  const rpcParams = encode(PreparedCall_SolanaV0_SignedSchema, params);
+  const rpcResp = await client.request({
+    method: "wallet_sendPreparedCalls",
+    params: [rpcParams],
+  });
+
+  LOGGER.debug("solana:sendPreparedCalls:done");
+  const decoded = decode(schema.response, rpcResp);
+
+  if (!isSolanaResponse(decoded)) {
+    throw new BaseError(
+      `Unexpected EVM response from Solana sendPreparedCalls: ${decoded.details.type}`,
+    );
+  }
+
+  return decoded;
+}

package/src/actions/solana/signPreparedCalls.ts

@@ -0,0 +1,50 @@
+import type { Prettify } from "viem";
+import type { InnerSolanaWalletApiClient } from "../../types.js";
+import {
+  signSolanaSignatureRequest,
+  type SolanaSignatureResult,
+} from "./signSignatureRequest.js";
+import type { SolanaPrepareCallsResult } from "./prepareCalls.js";
+import { LOGGER } from "../../logger.js";
+
+export type SolanaSignPreparedCallsParams = Prettify<SolanaPrepareCallsResult>;
+
+export type SolanaSignPreparedCallsResult = Prettify<
+  Omit<
+    SolanaPrepareCallsResult,
+    "signatureRequest" | "feePayment" | "details"
+  > & {
+    signature: SolanaSignatureResult;
+  }
+>;
+
+/**
+ * Signs a prepared Solana transaction using the client's Ed25519 signer.
+ *
+ * @param {InnerSolanaWalletApiClient} client - The Solana wallet client
+ * @param {SolanaSignPreparedCallsParams} params - The prepared Solana transaction with signature request
+ * @returns {Promise<SolanaSignPreparedCallsResult>} The signed Solana transaction
+ *
+ * @example
+ * ```ts
+ * const prepared = await client.prepareCalls({ ... });
+ * const signed = await client.signPreparedCalls(prepared);
+ * const result = await client.sendPreparedCalls(signed);
+ * ```
+ */
+export async function signPreparedCalls(
+  client: InnerSolanaWalletApiClient,
+  params: SolanaSignPreparedCallsParams,
+): Promise<SolanaSignPreparedCallsResult> {
+  LOGGER.debug("solana:signPreparedCalls:start");
+
+  const signature = await signSolanaSignatureRequest(
+    client.owner,
+    params.signatureRequest,
+  );
+
+  const { signatureRequest: _, feePayment: __, details: ___, ...rest } = params;
+
+  LOGGER.debug("solana:signPreparedCalls:done");
+  return { ...rest, signature };
+}

package/src/actions/solana/signSignatureRequest.ts

@@ -0,0 +1,63 @@
+import type { SolanaSigner } from "../../types.js";
+import { LOGGER } from "../../logger.js";
+import { hexToBytes } from "viem";
+import { Base58 } from "ox";
+import { findSignerSlot } from "../../adapters/resolveSignerSlot.js";
+import { SolanaSignerError } from "../../adapters/SolanaSignerError.js";
+
+export type SolanaSignatureRequestParams = {
+  type: "solana_signTransaction";
+  data: `0x${string}`;
+};
+
+export type SolanaSignatureResult = {
+  type: "ed25519";
+  data: string;
+};
+
+export async function signSolanaSignatureRequest(
+  signer: SolanaSigner,
+  signatureRequest: SolanaSignatureRequestParams,
+): Promise<SolanaSignatureResult> {
+  const txBytes = hexToBytes(signatureRequest.data);
+
+  const slotIndex = await findSignerSlot(txBytes, signer.address);
+  if (slotIndex < 0) {
+    throw new SolanaSignerError(
+      `Signer ${signer.address} is not a required signer in this transaction`,
+    );
+  }
+
+  LOGGER.debug("signSolanaSignatureRequest:signing");
+
+  const { signedTransaction } = await signer.signTransaction({
+    transaction: txBytes,
+  });
+
+  if (signedTransaction[0] !== txBytes[0]) {
+    throw new SolanaSignerError(
+      `Signer returned a transaction with a different signature count (expected ${txBytes[0]}, got ${signedTransaction[0]})`,
+    );
+  }
+
+  const offset = 1 + slotIndex * 64;
+  const rawSignature = signedTransaction.slice(offset, offset + 64);
+
+  if (rawSignature.length !== 64) {
+    throw new SolanaSignerError(
+      `Signed transaction too short to contain signature at slot ${slotIndex}`,
+    );
+  }
+
+  if (rawSignature.every((b) => b === 0)) {
+    throw new SolanaSignerError(
+      `Signer ${signer.address} did not produce a signature at slot ${slotIndex}`,
+    );
+  }
+
+  LOGGER.debug("signSolanaSignatureRequest:ok");
+  return {
+    type: "ed25519",
+    data: Base58.fromBytes(rawSignature),
+  };
+}

package/src/actions/solana/waitForCallsStatus.ts

@@ -0,0 +1,84 @@
+import type { InnerSolanaWalletApiClient } from "../../types.js";
+import {
+  getCallsStatus,
+  type SolanaGetCallsStatusResult,
+} from "./getCallsStatus.js";
+import { BaseError } from "@alchemy/common";
+import { LOGGER } from "../../logger.js";
+
+export type SolanaWaitForCallsStatusParams = {
+  id: `0x${string}`;
+  pollingInterval?: number;
+  retryCount?: number;
+  retryDelay?: (opts: { count: number }) => number;
+  status?: (result: SolanaGetCallsStatusResult) => boolean;
+  throwOnFailure?: boolean;
+  timeout?: number;
+};
+
+export type SolanaWaitForCallsStatusResult = SolanaGetCallsStatusResult;
+
+/**
+ * Polls getCallsStatus until the call reaches a terminal state.
+ * Similar API to viem's waitForCallsStatus with retry, exponential backoff,
+ * configurable status predicate, throwOnFailure, and timeout.
+ *
+ * @param {InnerSolanaWalletApiClient} client - The Solana wallet API client
+ * @param {SolanaWaitForCallsStatusParams} params - The call ID and optional polling config
+ * @returns {Promise<SolanaWaitForCallsStatusResult>} The final status
+ */
+export async function waitForCallsStatus(
+  client: InnerSolanaWalletApiClient,
+  params: SolanaWaitForCallsStatusParams,
+): Promise<SolanaWaitForCallsStatusResult> {
+  const {
+    id,
+    pollingInterval = client.pollingInterval,
+    retryCount = 4,
+    retryDelay = ({ count }: { count: number }) => ~~(1 << count) * 200,
+    status: isReady = ({ statusCode }) =>
+      statusCode === 200 || statusCode >= 300,
+    throwOnFailure = false,
+    timeout = 60_000,
+  } = params;
+
+  LOGGER.debug("solana:waitForCallsStatus:start", { id });
+
+  const start = Date.now();
+
+  while (Date.now() - start < timeout) {
+    let result: SolanaGetCallsStatusResult | undefined;
+
+    for (let attempt = 0; attempt <= retryCount; attempt++) {
+      try {
+        result = await getCallsStatus(client, { id });
+        break;
+      } catch (error) {
+        if (attempt >= retryCount) throw error;
+        await new Promise((r) => setTimeout(r, retryDelay({ count: attempt })));
+      }
+    }
+
+    if (!result) throw new BaseError("Unexpected: no result after retries");
+
+    if (throwOnFailure && result.status === "failure") {
+      throw new BaseError(
+        `Solana call bundle failed with status code ${result.statusCode}`,
+      );
+    }
+
+    if (isReady(result)) {
+      LOGGER.debug("solana:waitForCallsStatus:done", {
+        status: result.status,
+        statusCode: result.statusCode,
+      });
+      return result;
+    }
+
+    await new Promise((r) => setTimeout(r, pollingInterval));
+  }
+
+  throw new BaseError(
+    `Timed out while waiting for call bundle with id "${id}" to be confirmed.`,
+  );
+}

package/src/actions/undelegateAccount.ts

@@ -0,0 +1,68 @@
+import { zeroAddress, type Chain, type Prettify } from "viem";
+import type { InnerWalletApiClient } from "../types.js";
+import { LOGGER } from "../logger.js";
+import { resolveAddress, type AccountParam } from "../utils/resolve.js";
+import { sendCalls, type SendCallsResult } from "./sendCalls.js";
+
+export type UndelegateAccountParams = Prettify<{
+  account?: AccountParam;
+  chain?: Pick<Chain, "id">;
+  capabilities?: {
+    paymaster?: {
+      policyId: string;
+    };
+  };
+}>;
+
+export type UndelegateAccountResult = Prettify<SendCallsResult>;
+
+/**
+ * Prepares, signs, and sends an EIP-7702 undelegation to remove delegation from an EOA.
+ * Gas is sponsored by Alchemy (requires Enterprise plan).
+ *
+ * A BSO (Bundler Sponsorship Override) policy ID must be provided either via
+ * `params.capabilities.paymaster.policyId` or pre-configured on the client via `policyIds`.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {UndelegateAccountParams} params - Parameters for undelegating the account
+ * @param {AccountParam} [params.account] - The account to undelegate. Defaults to the client's account (signer address).
+ * @param {object} [params.chain] - The chain. Defaults to the client's chain.
+ * @param {object} [params.capabilities] - Optional capabilities. If omitted, falls back to the policy ID(s) set on the client.
+ * @param {object} [params.capabilities.paymaster] - Paymaster capabilities. Requires a BSO policy ID.
+ * @param {string} [params.capabilities.paymaster.policyId] - The BSO policy ID to use for gas sponsorship.
+ * @returns {Promise<UndelegateAccountResult>} A Promise that resolves to the result containing the call ID.
+ *
+ * @example
+ * ```ts
+ * const result = await client.undelegateAccount();
+ * const status = await client.waitForCallsStatus({ id: result.id });
+ * ```
+ */
+export async function undelegateAccount(
+  client: InnerWalletApiClient,
+  params?: UndelegateAccountParams,
+): Promise<UndelegateAccountResult> {
+  const account = params?.account
+    ? resolveAddress(params.account)
+    : client.account.address;
+
+  LOGGER.info("undelegateAccount:start", {
+    account,
+    chain: params?.chain,
+  });
+
+  const result = await sendCalls(client, {
+    calls: [],
+    account,
+    ...(params?.chain != null ? { chain: params.chain } : {}),
+    capabilities: {
+      ...params?.capabilities,
+      eip7702Auth: {
+        delegation: zeroAddress,
+      },
+    },
+  });
+
+  LOGGER.info("undelegateAccount:done", { id: result.id });
+  return result;
+}

package/src/adapters/SolanaSignerError.ts

@@ -0,0 +1,5 @@
+import { BaseError } from "@alchemy/common";
+
+export class SolanaSignerError extends BaseError {
+  override name = "SolanaSignerError";
+}

package/src/adapters/fromKeypair.ts

@@ -0,0 +1,58 @@
+import type { SolanaSigner } from "../types.js";
+import { SolanaSignerError } from "./SolanaSignerError.js";
+import { findSignerSlot } from "./resolveSignerSlot.js";
+
+/** Raw Ed25519 keypair signer (e.g. `Keypair` from `@solana/web3.js` v1 or a bare Ed25519 key). */
+export interface SolanaKeypairSigner {
+  address: string;
+  signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+
+/**
+ * Adapts a raw Ed25519 keypair signer into a {@link SolanaSigner}.
+ *
+ * Use this for legacy `@solana/web3.js` v1 `Keypair` signers or any signer
+ * that exposes a `signMessage(bytes) => signature` interface. For
+ * `@solana/kit` signers, use {@link fromKitSigner}. For browser wallets
+ * (wallet adapter, Phantom, etc.), use {@link fromWalletAdapter}. For
+ * wallet-standard wallets, use {@link fromWalletStandard}.
+ *
+ * Requires `@solana/kit` or `@solana/web3.js` as a peer dependency.
+ *
+ * @param {SolanaKeypairSigner} signer - The raw Ed25519 keypair signer to adapt
+ * @returns {SolanaSigner} A SolanaSigner compatible with `createSmartWalletClient`
+ */
+export function fromKeypair(signer: SolanaKeypairSigner): SolanaSigner {
+  return {
+    address: signer.address,
+    async signTransaction({ transaction }) {
+      const numSigs = transaction[0];
+      const messageStart = 1 + numSigs * 64;
+      const messageBytes = transaction.slice(messageStart);
+      let sig: Uint8Array;
+      try {
+        sig = await signer.signMessage(messageBytes);
+      } catch (e) {
+        throw new SolanaSignerError("Keypair signer failed to sign message", {
+          cause: e as Error,
+        });
+      }
+      if (sig.length !== 64) {
+        throw new SolanaSignerError(
+          `Expected a 64-byte Ed25519 signature but received ${sig.length} bytes`,
+        );
+      }
+
+      const slotIndex = await findSignerSlot(transaction, signer.address);
+      if (slotIndex < 0) {
+        throw new SolanaSignerError(
+          `Signer ${signer.address} is not a required signer in this transaction`,
+        );
+      }
+
+      const signedTx = new Uint8Array(transaction);
+      signedTx.set(sig, 1 + slotIndex * 64);
+      return { signedTransaction: signedTx };
+    },
+  };
+}

package/src/adapters/fromKitSigner.ts

@@ -0,0 +1,82 @@
+import type { SolanaSigner } from "../types.js";
+import { SolanaSignerError } from "./SolanaSignerError.js";
+import { findSignerSlot } from "./resolveSignerSlot.js";
+
+/** Any {@link https://solanakit.com @solana/kit} signer that implements `signTransactions` (e.g. `TransactionPartialSigner`, `KeyPairSigner`). */
+export interface SolanaTransactionPartialSigner {
+  address: string;
+  signTransactions(
+    transactions: readonly unknown[],
+  ): Promise<readonly Record<string, Uint8Array>[]>;
+}
+
+/**
+ * Adapts an {@link https://solanakit.com @solana/kit} signer into a {@link SolanaSigner}.
+ *
+ * Accepts any signer that implements `signTransactions`, including
+ * `KeyPairSigner`, `TransactionPartialSigner`, and `NoopSigner`. For raw
+ * Ed25519 keypairs, use {@link fromKeypair}. For browser wallets (wallet
+ * adapter, Phantom, etc.), use {@link fromWalletAdapter}. For
+ * wallet-standard wallets, use {@link fromWalletStandard}.
+ *
+ * Requires `@solana/kit` as a peer dependency.
+ *
+ * @param {SolanaTransactionPartialSigner} signer - The @solana/kit signer to adapt
+ * @returns {SolanaSigner} A SolanaSigner compatible with `createSmartWalletClient`
+ */
+export function fromKitSigner(
+  signer: SolanaTransactionPartialSigner,
+): SolanaSigner {
+  return {
+    address: signer.address,
+    async signTransaction({ transaction }) {
+      let tx: unknown;
+      try {
+        const { getTransactionCodec } = await import("@solana/kit");
+        const codec = getTransactionCodec();
+        tx = codec.decode(transaction);
+      } catch (e) {
+        throw new SolanaSignerError("Failed to decode transaction", {
+          cause: e as Error,
+        });
+      }
+
+      let sigDict: Record<string, Uint8Array> | undefined;
+      try {
+        [sigDict] = await signer.signTransactions([tx]);
+      } catch (e) {
+        throw new SolanaSignerError("Kit signer failed to sign transaction", {
+          cause: e as Error,
+        });
+      }
+      if (!sigDict) {
+        throw new SolanaSignerError(
+          "TransactionPartialSigner returned no signatures",
+        );
+      }
+
+      const sig = sigDict[signer.address];
+      if (!sig) {
+        throw new SolanaSignerError(
+          `TransactionPartialSigner did not produce a signature for ${signer.address}`,
+        );
+      }
+      if (sig.length !== 64) {
+        throw new SolanaSignerError(
+          `Expected a 64-byte Ed25519 signature but received ${sig.length} bytes`,
+        );
+      }
+
+      const slotIndex = await findSignerSlot(transaction, signer.address);
+      if (slotIndex < 0) {
+        throw new SolanaSignerError(
+          `Signer ${signer.address} is not a required signer in this transaction`,
+        );
+      }
+
+      const signedTx = new Uint8Array(transaction);
+      signedTx.set(sig, 1 + slotIndex * 64);
+      return { signedTransaction: signedTx };
+    },
+  };
+}