@account-kit/signer 4.15.2 → 4.16.0

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "4.15.2";
+export declare const VERSION = "4.16.0";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@account-kit/signer",
-  "version": "4.15.2",
+  "version": "4.16.0",
   "description": "Core interfaces and clients for interfacing with the Alchemy Signer API",
   "author": "Alchemy",
   "license": "MIT",
@@ -49,8 +49,9 @@
     "vitest": "^2.0.4"
   },
   "dependencies": {
-    "@aa-sdk/core": "^4.15.2",
-    "@account-kit/logging": "^4.15.2",
+    "@aa-sdk/core": "^4.16.0",
+    "@account-kit/logging": "^4.16.0",
+    "@solana/web3.js": "^1.98.0",
     "@turnkey/http": "^2.6.2",
     "@turnkey/iframe-stamper": "^1.0.0",
     "@turnkey/viem": "^0.4.8",
@@ -73,5 +74,5 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "c69762a97a77be62706accec8b9af908c836ccd5"
+  "gitHead": "d0a8f15fb7d10812c29b98f334d9705d46a31e7f"
 }

package/src/base.ts

@@ -16,6 +16,7 @@ import {
   type TypedDataDefinition,
 } from "viem";
 import { toAccount } from "viem/accounts";
+import { hashAuthorization, type Authorization } from "viem/experimental";
 import type { Mutate, StoreApi } from "zustand";
 import { subscribeWithSelector } from "zustand/middleware";
 import { createStore } from "zustand/vanilla";
@@ -27,7 +28,9 @@ import {
   SessionManager,
   type SessionManagerParams,
 } from "./session/manager.js";
+import type { SessionManagerEvents } from "./session/types";
 import type { AuthParams } from "./signer";
+import { SolanaSigner } from "./solanaSigner.js";
 import {
   AlchemySignerStatus,
   type AlchemySignerEvent,
@@ -35,8 +38,6 @@ import {
   type ErrorInfo,
 } from "./types.js";
 import { assertNever } from "./utils/typeAssertions.js";
-import type { SessionManagerEvents } from "./session/types";
-import { hashAuthorization, type Authorization } from "viem/experimental";
 
 export interface BaseAlchemySignerParams<TClient extends BaseSignerClient> {
   client: TClient;
@@ -733,6 +734,38 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
     });
   };
 
+  /**
+   * Creates a new instance of `SolanaSigner` using the provided inner value.
+   * This requires the signer to be authenticated first
+   *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const solanaSigner = signer.toSolanaSigner();
+   * ```
+   *
+   * @returns {SolanaSigner} A new instance of `SolanaSigner`
+   */
+  experimental_toSolanaSigner = (): SolanaSigner => {
+    if (!this.inner.getUser()) {
+      throw new NotAuthenticatedError();
+    }
+
+    return new SolanaSigner(this.inner);
+  };
+
   private authenticateWithEmail = async (
     params: Extract<AuthParams, { type: "email" }>
   ): Promise<User> => {

package/src/client/base.ts

@@ -4,9 +4,11 @@ import EventEmitter from "eventemitter3";
 import { jwtDecode } from "jwt-decode";
 import { sha256, type Hex } from "viem";
 import { NotAuthenticatedError, OAuthProvidersError } from "../errors.js";
+import { addOpenIdIfAbsent, getDefaultScopeAndClaims } from "../oauth.js";
+import type { OauthMode } from "../signer.js";
 import { base64UrlEncode } from "../utils/base64UrlEncode.js";
-import { assertNever } from "../utils/typeAssertions.js";
 import { resolveRelativeUrl } from "../utils/resolveRelativeUrl.js";
+import { assertNever } from "../utils/typeAssertions.js";
 import type {
   AlchemySignerClientEvent,
   AlchemySignerClientEvents,
@@ -25,8 +27,6 @@ import type {
   SignupResponse,
   User,
 } from "./types.js";
-import type { OauthMode } from "../signer.js";
-import { addOpenIdIfAbsent, getDefaultScopeAndClaims } from "../oauth.js";
 
 export interface BaseSignerClientParams {
   stamper: TurnkeyClient["stamper"];
@@ -159,6 +159,8 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
 
   public abstract lookupUserWithPasskey(user?: User): Promise<User>;
 
+  public abstract targetPublicKey(): Promise<string>;
+
   protected abstract getOauthConfig(): Promise<OauthConfig>;
 
   protected abstract getWebAuthnAttestation(
@@ -315,22 +317,35 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * that result here.
    *
    * @param {Hex} msg the hex representation of the bytes to sign
+   * @param {string} mode specify if signing should happen for solana or ethereum
    * @returns {Promise<Hex>} the signature over the raw hex
    */
-  public signRawMessage = async (msg: Hex): Promise<Hex> => {
+  public signRawMessage = async (
+    msg: Hex,
+    mode: "SOLANA" | "ETHEREUM" = "ETHEREUM"
+  ): Promise<Hex> => {
     if (!this.user) {
       throw new NotAuthenticatedError();
     }
 
+    if (!this.user.solanaAddress && mode === "SOLANA") {
+      // TODO: we need to add backwards compatibility for users who signed up before we added Solana support
+      throw new Error("No Solana address available for the user");
+    }
+
     const stampedRequest = await this.turnkeyClient.stampSignRawPayload({
       organizationId: this.user.orgId,
       type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
       timestampMs: Date.now().toString(),
       parameters: {
         encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
-        hashFunction: "HASH_FUNCTION_NO_OP",
+        hashFunction:
+          mode === "ETHEREUM"
+            ? "HASH_FUNCTION_NO_OP"
+            : "HASH_FUNCTION_NOT_APPLICABLE",
         payload: msg,
-        signWith: this.user.address,
+        signWith:
+          mode === "ETHEREUM" ? this.user.address : this.user.solanaAddress!,
       },
     });
 

package/src/client/index.ts

@@ -557,6 +557,31 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     });
   };
 
+  /**
+   * Initializes the iframe stamper and returns its public key.
+   *
+   * @example
+   * ```ts twoslash
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   *
+   * const publicKey = await client.targetPublicKey();
+   * ```
+   *
+   * @returns {Promise<string>} A promise that resolves with the target public key when the iframe stamper is successfully initialized, or throws an error if the target public key is not supported.
+   */
+  public override targetPublicKey = async (): Promise<string> => {
+    return this.initIframeStamper();
+  };
+
   private initIframeStamper = async () => {
     if (!this.iframeStamper.publicKey()) {
       await this.iframeStamper.init();

package/src/client/types.ts

@@ -13,6 +13,7 @@ export type User = {
   orgId: string;
   userId: string;
   address: Address;
+  solanaAddress?: string;
   credentialId?: string;
   idToken?: string;
   claims?: Record<string, unknown>;

package/src/index.ts

@@ -6,12 +6,13 @@ export {
   OauthFailedError,
 } from "./client/index.js";
 export type * from "./client/types.js";
+export { NotAuthenticatedError, OAuthProvidersError } from "./errors.js";
 export {
   DEFAULT_SESSION_MS,
   SessionManagerParamsSchema,
 } from "./session/manager.js";
 export type * from "./signer.js";
 export { AlchemyWebSigner } from "./signer.js";
+export type * from "./solanaSigner.js";
 export type * from "./types.js";
 export { AlchemySignerStatus } from "./types.js";
-export { OAuthProvidersError, NotAuthenticatedError } from "./errors.js";

package/src/solanaSigner.ts

@@ -0,0 +1,83 @@
+import {
+  PublicKey,
+  Transaction,
+  type VersionedTransaction,
+} from "@solana/web3.js";
+import { size, slice, toBytes, toHex, type ByteArray, type Hex } from "viem";
+import type { BaseSignerClient } from "./client/base";
+import { NotAuthenticatedError } from "./errors.js";
+
+// TODO: I don't want this to be a class so that the flow is closer to how we do this for `toViemAccount`
+export class SolanaSigner {
+  private alchemyClient: BaseSignerClient;
+  public address: string;
+
+  constructor(client: BaseSignerClient) {
+    this.alchemyClient = client;
+    if (!client.getUser()) throw new Error("Must be authenticated!");
+
+    // TODO: also throw here
+    this.address = client.getUser()!.solanaAddress!;
+  }
+
+  async addSignature(
+    tx: Transaction | VersionedTransaction
+  ): Promise<Transaction | VersionedTransaction> {
+    const user = this.alchemyClient.getUser();
+    if (!user) {
+      throw new NotAuthenticatedError();
+    }
+
+    if (!user.solanaAddress) {
+      throw new Error("no solana address");
+    }
+
+    const fromKey = new PublicKey(user.solanaAddress);
+    const messageToSign = this.getMessageToSign(tx);
+    const signature = await this.alchemyClient.signRawMessage(
+      messageToSign,
+      "SOLANA"
+    );
+
+    tx.addSignature(
+      fromKey,
+      Buffer.from(toBytes(this.formatSignatureForSolana(signature)))
+    );
+    return tx;
+  }
+
+  async signMessage(message: Uint8Array): Promise<ByteArray> {
+    const user = this.alchemyClient.getUser();
+    if (!user) {
+      throw new NotAuthenticatedError();
+    }
+
+    if (!user.solanaAddress) {
+      throw new Error("no solana address");
+    }
+
+    const messageToSign = toHex(message);
+    const signature = await this.alchemyClient.signRawMessage(
+      messageToSign,
+      "SOLANA"
+    );
+
+    return toBytes(this.formatSignatureForSolana(signature));
+  }
+
+  private formatSignatureForSolana(signature: Hex): Hex {
+    if (size(signature) === 64) return signature;
+
+    return slice(signature, 0, 64);
+  }
+
+  private getMessageToSign(tx: Transaction | VersionedTransaction): Hex {
+    let messageToSign;
+    if (tx instanceof Transaction) {
+      messageToSign = tx.serializeMessage();
+    } else {
+      messageToSign = Buffer.from(tx.message.serialize());
+    }
+    return toHex(messageToSign);
+  }
+}

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is autogenerated by inject-version.ts. Any changes will be
 // overwritten on commit!
-export const VERSION = "4.15.2";
+export const VERSION = "4.16.0";