@account-kit/signer 4.53.2-alpha.0 → 4.53.3-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@account-kit/signer",
-  "version": "4.53.2-alpha.0",
+  "version": "4.53.3-alpha.1",
   "description": "Core interfaces and clients for interfacing with the Alchemy Signer API",
   "author": "Alchemy",
   "license": "MIT",
@@ -48,8 +48,8 @@
     "typescript-template": "*"
   },
   "dependencies": {
-    "@aa-sdk/core": "^4.53.2-alpha.0",
-    "@account-kit/logging": "^4.53.2-alpha.0",
+    "@aa-sdk/core": "^4.53.3-alpha.1",
+    "@account-kit/logging": "^4.53.3-alpha.1",
     "@noble/curves": "^1.9.2",
     "@noble/hashes": "1.7.1",
     "@noble/secp256k1": "^2.3.0",
@@ -78,5 +78,5 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "9e39392f36bd934e112bb8c8feb3c1cc4e33806b"
+  "gitHead": "2f54bc3fdeeb6fae8f9dd8c570485bf424174048"
 }

package/src/base.ts

@@ -330,8 +330,6 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
             return this.handleOauthReturn(params);
           case "otp":
             return this.authenticateWithOtp(params);
-          case "custom-jwt":
-            return this.authenticateWithJwt(params);
           default:
             assertNever(type, `Unknown auth type: ${type}`);
         }
@@ -387,16 +385,6 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
         });
         return;
       }
-      case "custom-jwt": {
-        SignerLogger.trackEvent({
-          name: "signer_authnticate",
-          data: {
-            authType: "custom-jwt",
-            provider: params.authProviderId,
-          },
-        });
-        return;
-      }
       case "oauth":
         SignerLogger.trackEvent({
           name: "signer_authnticate",
@@ -1225,26 +1213,6 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
     return this.inner.listAuthMethods();
   };
 
-  private authenticateWithJwt = async (
-    args: Extract<AuthParams, { type: "custom-jwt" }>,
-  ): Promise<User> => {
-    const { credentialBundle, orgId, isSignUp } = await this.inner.submitJwt({
-      jwt: args.jwt,
-      authProvider: args.authProviderId,
-      expirationSeconds: this.getExpirationSeconds(),
-    });
-
-    const user = await this.inner.completeAuthWithBundle({
-      bundle: credentialBundle,
-      orgId: orgId,
-      connectedEventName: "connectedJwt",
-      authenticatingType: "custom-jwt",
-    });
-
-    this.emitNewUserEvent(isSignUp);
-    return user;
-  };
-
   private authenticateWithOtp = async (
     args: Extract<AuthParams, { type: "otp" }>,
   ): Promise<User> => {
@@ -1431,8 +1399,6 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
             return AlchemySignerStatus.AWAITING_OTP_AUTH;
           case "sms":
             return AlchemySignerStatus.AWAITING_SMS_AUTH;
-          case "custom-jwt":
-            return AlchemySignerStatus.AUTHENTICATING_JWT;
           default:
             assertNever(type, "unhandled authenticating type");
         }

package/src/client/base.ts

@@ -29,8 +29,6 @@ import type {
   GetOauthProviderUrlArgs,
   GetWebAuthnAttestationResult,
   MfaFactor,
-  JwtParams,
-  JwtResponse,
   OauthConfig,
   OauthParams,
   OauthState,
@@ -257,10 +255,6 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     args: Omit<OtpParams, "targetPublicKey">,
   ): Promise<SubmitOtpCodeResponse>;
 
-  public abstract submitJwt(
-    args: Omit<JwtParams, "targetPublicKey">,
-  ): Promise<JwtResponse>;
-
   public abstract disconnect(): Promise<void>;
 
   public abstract exportWallet(params: TExportWalletParams): Promise<boolean>;

package/src/client/index.ts

@@ -14,8 +14,6 @@ import type {
   ExportWalletParams,
   OauthConfig,
   OtpParams,
-  JwtParams,
-  JwtResponse,
   User,
   SubmitOtpCodeResponse,
   AuthLinkingPrompt,
@@ -261,44 +259,6 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     );
   }
 
-  /**
-   * Authenticates using a custom issued JWT
-   *
-   * @example
-   * ```ts
-   * import { AlchemySignerWebClient } from "@account-kit/signer";
-   *
-   * const client = new AlchemySignerWebClient({
-   *  connection: {
-   *    apiKey: "your-api-key",
-   *  },
-   *  iframeConfig: {
-   *   iframeContainerId: "signer-iframe-container",
-   *  },
-   * });
-   *
-   * const account = await client.submitJwt({
-   *   jwt: "custom-issued-jwt",
-   *   authProvider: "auth-provider-name",
-   * });
-   * ```
-   *
-   * @param {Omit<JwtParams, "targetPublicKey">} args The parameters for the JWT request, excluding the target public key.
-   * @returns {Promise<{ bundle: string }>} A promise that resolves to an object containing the credential bundle.
-   */
-  public override async submitJwt(
-    args: Omit<JwtParams, "targetPublicKey">,
-  ): Promise<JwtResponse> {
-    this.eventEmitter.emit("authenticating", { type: "custom-jwt" });
-    const targetPublicKey = await this.initSessionStamper();
-    return this.request("/v1/auth-jwt", {
-      jwt: args.jwt,
-      targetPublicKey,
-      authProvider: args.authProvider,
-      expirationSeconds: args?.expirationSeconds,
-    });
-  }
-
   /**
    * Completes auth for the user by injecting a credential bundle and retrieving
    * the user information based on the provided organization ID. Emits events

package/src/client/types.ts

@@ -95,19 +95,6 @@ export type OtpResponse =
       multiFactors: MfaFactor[];
     };
 
-export type JwtParams = {
-  jwt: string;
-  targetPublicKey: string;
-  authProvider: string;
-  expirationSeconds?: number;
-};
-
-export type JwtResponse = {
-  isSignUp: boolean;
-  orgId: string;
-  credentialBundle: string;
-};
-
 export type SignupResponse = {
   orgId: string;
   userId?: string;
@@ -276,11 +263,6 @@ export type SignerEndpoints = [
       multiFactors: MfaFactor[];
     };
   },
-  {
-    Route: "/v1/auth-jwt";
-    Body: JwtParams;
-    Response: JwtResponse;
-  },
   {
     Route: "/v1/signer-config";
     Body: {};
@@ -365,14 +347,7 @@ export type SignerEndpoints = [
 ];
 
 export type AuthenticatingEventMetadata = {
-  type:
-    | "email"
-    | "passkey"
-    | "oauth"
-    | "otp"
-    | "otpVerify"
-    | "custom-jwt"
-    | "sms";
+  type: "email" | "passkey" | "oauth" | "otp" | "otpVerify" | "sms";
 };
 
 export type AlchemySignerClientEvents = {
@@ -383,7 +358,6 @@ export type AlchemySignerClientEvents = {
   connectedPasskey(user: User): void;
   connectedOauth(user: User, bundle: string): void;
   connectedOtp(user: User, bundle: string): void;
-  connectedJwt(user: User, bundle: string): void;
   disconnected(): void;
 };
 

package/src/index.ts

@@ -21,3 +21,7 @@ export type * from "./solanaSigner.js";
 export type * from "./types.js";
 export { AlchemySignerStatus } from "./types.js";
 export { SolanaSigner } from "./solanaSigner.js";
+export {
+  createSolanaSponsoredTransaction,
+  createSolanaTransaction,
+} from "./utils/solana.js";

package/src/metrics.ts

@@ -15,8 +15,7 @@ export type SignerEventsSchema = [
             | "oauthReturn";
           provider?: never;
         }
-      | { authType: "oauth"; provider: string }
-      | { authType: "custom-jwt"; provider: string };
+      | { authType: "oauth"; provider: string };
   },
   {
     EventName: "signer_sign_message";

package/src/session/manager.ts

@@ -97,7 +97,6 @@ export class SessionManager {
     switch (existingSession.type) {
       case "email":
       case "oauth":
-      case "custom-jwt":
       case "otp": {
         const connectedEventName = (() => {
           switch (existingSession.type) {
@@ -107,8 +106,6 @@ export class SessionManager {
               return "connectedOauth";
             case "otp":
               return "connectedOtp";
-            case "custom-jwt":
-              return "connectedJwt";
           }
         })();
         const result = await this.client
@@ -211,7 +208,7 @@ export class SessionManager {
   private setSession = (
     session_:
       | Omit<
-          Extract<Session, { type: "email" | "oauth" | "otp" | "custom-jwt" }>,
+          Extract<Session, { type: "email" | "oauth" | "otp" }>,
           "expirationDateMs"
         >
       | Omit<Extract<Session, { type: "passkey" }>, "expirationDateMs">,
@@ -287,9 +284,6 @@ export class SessionManager {
       connectedOtp: (user, bundle) => {
         this.setSessionWithUserAndBundle({ type: "otp", user, bundle });
       },
-      connectedJwt: (user, bundle) => {
-        this.setSessionWithUserAndBundle({ type: "custom-jwt", user, bundle });
-      },
       disconnected: () => this.clearSession(),
     };
 
@@ -345,7 +339,7 @@ export class SessionManager {
     user,
     bundle,
   }: {
-    type: "email" | "oauth" | "otp" | "custom-jwt";
+    type: "email" | "oauth" | "otp";
     user: User;
     bundle: string;
   }) => {

package/src/session/types.ts

@@ -2,7 +2,7 @@ import type { User } from "../client/types";
 
 export type Session =
   | {
-      type: "email" | "oauth" | "otp" | "custom-jwt";
+      type: "email" | "oauth" | "otp";
       bundle: string;
       expirationDateMs: number;
       user: User;

package/src/signer.ts

@@ -54,10 +54,6 @@ export type AuthParams =
       idToken: string;
       isNewUser?: boolean;
     }
-  | ({
-      type: "custom-jwt";
-      jwt: string;
-    } & OauthProviderConfig)
   | {
       type: "otp";
       otpCode: string;

package/src/solanaSigner.ts

@@ -9,6 +9,7 @@ import {
 import { size, slice, toBytes, toHex, type ByteArray, type Hex } from "viem";
 import type { BaseSignerClient } from "./client/base";
 import { NotAuthenticatedError } from "./errors.js";
+import { createSolanaSponsoredTransaction } from "./utils/solana.js";
 
 /**
  * The SolanaSigner class is used to sign transactions and messages for the Solana blockchain.
@@ -159,53 +160,11 @@ export class SolanaSigner {
     connection: Connection,
     policyId: string,
   ): Promise<VersionedTransaction> {
-    const { blockhash } = await connection.getLatestBlockhash({
-      commitment: "finalized",
-    });
-    const message = new TransactionMessage({
-      // Right now the backend will rewrite this payer Key to the server's address
-      payerKey: new PublicKey(this.address),
-      recentBlockhash: blockhash,
+    return createSolanaSponsoredTransaction(
       instructions,
-    }).compileToV0Message();
-    const versionedTransaction = new VersionedTransaction(message);
-    const serializedTransaction = Buffer.from(
-      versionedTransaction.serialize(),
-    ).toString("base64");
-    const body = JSON.stringify({
-      id: crypto?.randomUUID() ?? Math.floor(Math.random() * 1000000),
-      jsonrpc: "2.0",
-      method: "alchemy_requestFeePayer",
-      params: [
-        {
-          policyId,
-          serializedTransaction,
-        },
-      ],
-    });
-    const options = {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "content-type": "application/json",
-      },
-      body,
-    };
-
-    const response = await fetch(
-      // TODO: Use the connection??
-      connection.rpcEndpoint,
-      options,
-    );
-    const jsonResponse = await response.json();
-    if (!jsonResponse?.result?.serializedTransaction)
-      throw new Error(
-        `Response doesn't include the serializedTransaction ${JSON.stringify(
-          jsonResponse,
-        )}`,
-      );
-    return VersionedTransaction.deserialize(
-      decodeBase64(jsonResponse.result.serializedTransaction),
+      connection,
+      policyId,
+      this.address,
     );
   }
 
@@ -225,6 +184,3 @@ export class SolanaSigner {
     return toHex(messageToSign);
   }
 }
-function decodeBase64(serializedTransaction: string): Uint8Array {
-  return Buffer.from(serializedTransaction, "base64");
-}

package/src/types.ts

@@ -23,7 +23,6 @@ export enum AlchemySignerStatus {
   AUTHENTICATING_PASSKEY = "AUTHENTICATING_PASSKEY",
   AUTHENTICATING_EMAIL = "AUTHENTICATING_EMAIL",
   AUTHENTICATING_OAUTH = "AUTHENTICATING_OAUTH",
-  AUTHENTICATING_JWT = "AUTHENTICATING_JWT",
   AWAITING_EMAIL_AUTH = "AWAITING_EMAIL_AUTH",
   AWAITING_SMS_AUTH = "AWAITING_SMS_AUTH",
   AWAITING_OTP_AUTH = "AWAITING_OTP_AUTH",

package/src/utils/solana.ts

@@ -0,0 +1,100 @@
+import type { TransactionInstruction } from "@solana/web3.js";
+import {
+  Connection,
+  PublicKey,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+
+/**
+ * This function wraps instructions in a sponsored transaction using Alchemy's fee payer service
+ *
+ * @param {TransactionInstruction[]} instructions - The instructions to add sponsorship to
+ * @param {Connection} connection - The connection to use
+ * @param {string} policyId - The policy id to use
+ * @param {string} address - The address to use
+ * @returns {Promise<VersionedTransaction>} - The sponsored transaction
+ */
+export async function createSolanaSponsoredTransaction(
+  instructions: TransactionInstruction[],
+  connection: Connection,
+  policyId: string,
+  address: string,
+): Promise<VersionedTransaction> {
+  const { blockhash } = await connection.getLatestBlockhash({
+    commitment: "finalized",
+  });
+  const message = new TransactionMessage({
+    // Right now the backend will rewrite this payer Key to the server's address
+    payerKey: new PublicKey(address),
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message();
+  const versionedTransaction = new VersionedTransaction(message);
+  const serializedTransaction = Buffer.from(
+    versionedTransaction.serialize(),
+  ).toString("base64");
+  const body = JSON.stringify({
+    id: crypto?.randomUUID() ?? Math.floor(Math.random() * 1000000),
+    jsonrpc: "2.0",
+    method: "alchemy_requestFeePayer",
+    params: [
+      {
+        policyId,
+        serializedTransaction,
+      },
+    ],
+  });
+  const options = {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+    },
+    body,
+  };
+
+  const response = await fetch(
+    // TODO: Use the connection??
+    connection.rpcEndpoint,
+    options,
+  );
+  const jsonResponse = await response.json();
+  if (!jsonResponse?.result?.serializedTransaction)
+    throw new Error(
+      `Response doesn't include the serializedTransaction ${JSON.stringify(
+        jsonResponse,
+      )}`,
+    );
+  return VersionedTransaction.deserialize(
+    decodeBase64(jsonResponse.result.serializedTransaction),
+  );
+}
+
+/**
+ * Creates a regular (non-sponsored) Solana transaction from instructions
+ *
+ * @param {TransactionInstruction[]} instructions - The instructions to create transaction from
+ * @param {Connection} connection - The connection to use
+ * @param {string} address - The payer address
+ * @returns {Promise<VersionedTransaction>} - The transaction
+ */
+export async function createSolanaTransaction(
+  instructions: TransactionInstruction[],
+  connection: Connection,
+  address: string,
+): Promise<VersionedTransaction> {
+  const { blockhash } = await connection.getLatestBlockhash({
+    commitment: "finalized",
+  });
+  const message = new TransactionMessage({
+    payerKey: new PublicKey(address),
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message();
+  return new VersionedTransaction(message);
+}
+
+function decodeBase64(serializedTransaction: string): Uint8Array {
+  return Buffer.from(serializedTransaction, "base64");
+}

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.53.2-alpha.0";
+export const VERSION = "4.53.3-alpha.1";