@account-kit/signer 4.53.1-alpha.0 → 4.53.2-alpha.0

package/src/client/index.ts

@@ -14,6 +14,8 @@ import type {
   ExportWalletParams,
   OauthConfig,
   OtpParams,
+  JwtParams,
+  JwtResponse,
   User,
   SubmitOtpCodeResponse,
   AuthLinkingPrompt,
@@ -259,6 +261,44 @@ 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,6 +95,19 @@ 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;
@@ -263,6 +276,11 @@ export type SignerEndpoints = [
       multiFactors: MfaFactor[];
     };
   },
+  {
+    Route: "/v1/auth-jwt";
+    Body: JwtParams;
+    Response: JwtResponse;
+  },
   {
     Route: "/v1/signer-config";
     Body: {};
@@ -347,7 +365,14 @@ export type SignerEndpoints = [
 ];
 
 export type AuthenticatingEventMetadata = {
-  type: "email" | "passkey" | "oauth" | "otp" | "otpVerify" | "sms";
+  type:
+    | "email"
+    | "passkey"
+    | "oauth"
+    | "otp"
+    | "otpVerify"
+    | "custom-jwt"
+    | "sms";
 };
 
 export type AlchemySignerClientEvents = {
@@ -358,6 +383,7 @@ 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,7 +21,3 @@ 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,7 +15,8 @@ export type SignerEventsSchema = [
             | "oauthReturn";
           provider?: never;
         }
-      | { authType: "oauth"; provider: string };
+      | { authType: "oauth"; provider: string }
+      | { authType: "custom-jwt"; provider: string };
   },
   {
     EventName: "signer_sign_message";

package/src/session/manager.ts

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

package/src/signer.ts

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

package/src/solanaSigner.ts

@@ -9,7 +9,6 @@ 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.
@@ -160,11 +159,53 @@ export class SolanaSigner {
     connection: Connection,
     policyId: string,
   ): Promise<VersionedTransaction> {
-    return createSolanaSponsoredTransaction(
+    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,
       instructions,
-      connection,
-      policyId,
-      this.address,
+    }).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),
     );
   }
 
@@ -184,3 +225,6 @@ export class SolanaSigner {
     return toHex(messageToSign);
   }
 }
+function decodeBase64(serializedTransaction: string): Uint8Array {
+  return Buffer.from(serializedTransaction, "base64");
+}

package/src/types.ts

@@ -23,6 +23,7 @@ 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/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.1-alpha.0";
+export const VERSION = "4.53.2-alpha.0";

package/dist/esm/utils/solana.d.ts

@@ -1,21 +0,0 @@
-import type { TransactionInstruction } from "@solana/web3.js";
-import { Connection, 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 declare function createSolanaSponsoredTransaction(instructions: TransactionInstruction[], connection: Connection, policyId: string, address: string): Promise<VersionedTransaction>;
-/**
- * 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 declare function createSolanaTransaction(instructions: TransactionInstruction[], connection: Connection, address: string): Promise<VersionedTransaction>;

package/dist/esm/utils/solana.js

@@ -1,72 +0,0 @@
-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, connection, policyId, address) {
-    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, connection, address) {
-    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) {
-    return Buffer.from(serializedTransaction, "base64");
-}
-//# sourceMappingURL=solana.js.map

package/dist/esm/utils/solana.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"solana.js","sourceRoot":"","sources":["../../../src/utils/solana.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,SAAS,EACT,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gCAAgC,CACpD,YAAsC,EACtC,UAAsB,EACtB,QAAgB,EAChB,OAAe;IAEf,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,UAAU,CAAC,kBAAkB,CAAC;QACxD,UAAU,EAAE,WAAW;KACxB,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,IAAI,kBAAkB,CAAC;QACrC,4EAA4E;QAC5E,QAAQ,EAAE,IAAI,SAAS,CAAC,OAAO,CAAC;QAChC,eAAe,EAAE,SAAS;QAC1B,YAAY;KACb,CAAC,CAAC,kBAAkB,EAAE,CAAC;IACxB,MAAM,oBAAoB,GAAG,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC/D,MAAM,qBAAqB,GAAG,MAAM,CAAC,IAAI,CACvC,oBAAoB,CAAC,SAAS,EAAE,CACjC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACrB,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC;QAC1B,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;QAC/D,OAAO,EAAE,KAAK;QACd,MAAM,EAAE,yBAAyB;QACjC,MAAM,EAAE;YACN;gBACE,QAAQ;gBACR,qBAAqB;aACtB;SACF;KACF,CAAC,CAAC;IACH,MAAM,OAAO,GAAG;QACd,MAAM,EAAE,MAAM;QACd,OAAO,EAAE;YACP,MAAM,EAAE,kBAAkB;YAC1B,cAAc,EAAE,kBAAkB;SACnC;QACD,IAAI;KACL,CAAC;IAEF,MAAM,QAAQ,GAAG,MAAM,KAAK;IAC1B,6BAA6B;IAC7B,UAAU,CAAC,WAAW,EACtB,OAAO,CACR,CAAC;IACF,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC3C,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,qBAAqB;QAC9C,MAAM,IAAI,KAAK,CACb,sDAAsD,IAAI,CAAC,SAAS,CAClE,YAAY,CACb,EAAE,CACJ,CAAC;IACJ,OAAO,oBAAoB,CAAC,WAAW,CACrC,YAAY,CAAC,YAAY,CAAC,MAAM,CAAC,qBAAqB,CAAC,CACxD,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,YAAsC,EACtC,UAAsB,EACtB,OAAe;IAEf,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,UAAU,CAAC,kBAAkB,CAAC;QACxD,UAAU,EAAE,WAAW;KACxB,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,IAAI,kBAAkB,CAAC;QACrC,QAAQ,EAAE,IAAI,SAAS,CAAC,OAAO,CAAC;QAChC,eAAe,EAAE,SAAS;QAC1B,YAAY;KACb,CAAC,CAAC,kBAAkB,EAAE,CAAC;IACxB,OAAO,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,YAAY,CAAC,qBAA6B;IACjD,OAAO,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAC;AACtD,CAAC","sourcesContent":["import type { TransactionInstruction } from \"@solana/web3.js\";\nimport {\n  Connection,\n  PublicKey,\n  TransactionMessage,\n  VersionedTransaction,\n} from \"@solana/web3.js\";\n\n/**\n * This function wraps instructions in a sponsored transaction using Alchemy's fee payer service\n *\n * @param {TransactionInstruction[]} instructions - The instructions to add sponsorship to\n * @param {Connection} connection - The connection to use\n * @param {string} policyId - The policy id to use\n * @param {string} address - The address to use\n * @returns {Promise<VersionedTransaction>} - The sponsored transaction\n */\nexport async function createSolanaSponsoredTransaction(\n  instructions: TransactionInstruction[],\n  connection: Connection,\n  policyId: string,\n  address: string,\n): Promise<VersionedTransaction> {\n  const { blockhash } = await connection.getLatestBlockhash({\n    commitment: \"finalized\",\n  });\n  const message = new TransactionMessage({\n    // Right now the backend will rewrite this payer Key to the server's address\n    payerKey: new PublicKey(address),\n    recentBlockhash: blockhash,\n    instructions,\n  }).compileToV0Message();\n  const versionedTransaction = new VersionedTransaction(message);\n  const serializedTransaction = Buffer.from(\n    versionedTransaction.serialize(),\n  ).toString(\"base64\");\n  const body = JSON.stringify({\n    id: crypto?.randomUUID() ?? Math.floor(Math.random() * 1000000),\n    jsonrpc: \"2.0\",\n    method: \"alchemy_requestFeePayer\",\n    params: [\n      {\n        policyId,\n        serializedTransaction,\n      },\n    ],\n  });\n  const options = {\n    method: \"POST\",\n    headers: {\n      accept: \"application/json\",\n      \"content-type\": \"application/json\",\n    },\n    body,\n  };\n\n  const response = await fetch(\n    // TODO: Use the connection??\n    connection.rpcEndpoint,\n    options,\n  );\n  const jsonResponse = await response.json();\n  if (!jsonResponse?.result?.serializedTransaction)\n    throw new Error(\n      `Response doesn't include the serializedTransaction ${JSON.stringify(\n        jsonResponse,\n      )}`,\n    );\n  return VersionedTransaction.deserialize(\n    decodeBase64(jsonResponse.result.serializedTransaction),\n  );\n}\n\n/**\n * Creates a regular (non-sponsored) Solana transaction from instructions\n *\n * @param {TransactionInstruction[]} instructions - The instructions to create transaction from\n * @param {Connection} connection - The connection to use\n * @param {string} address - The payer address\n * @returns {Promise<VersionedTransaction>} - The transaction\n */\nexport async function createSolanaTransaction(\n  instructions: TransactionInstruction[],\n  connection: Connection,\n  address: string,\n): Promise<VersionedTransaction> {\n  const { blockhash } = await connection.getLatestBlockhash({\n    commitment: \"finalized\",\n  });\n  const message = new TransactionMessage({\n    payerKey: new PublicKey(address),\n    recentBlockhash: blockhash,\n    instructions,\n  }).compileToV0Message();\n  return new VersionedTransaction(message);\n}\n\nfunction decodeBase64(serializedTransaction: string): Uint8Array {\n  return Buffer.from(serializedTransaction, \"base64\");\n}\n"]}

package/dist/types/utils/solana.d.ts

@@ -1,22 +0,0 @@
-import type { TransactionInstruction } from "@solana/web3.js";
-import { Connection, 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 declare function createSolanaSponsoredTransaction(instructions: TransactionInstruction[], connection: Connection, policyId: string, address: string): Promise<VersionedTransaction>;
-/**
- * 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 declare function createSolanaTransaction(instructions: TransactionInstruction[], connection: Connection, address: string): Promise<VersionedTransaction>;
-//# sourceMappingURL=solana.d.ts.map

package/dist/types/utils/solana.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"solana.d.ts","sourceRoot":"","sources":["../../../src/utils/solana.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EACL,UAAU,EAGV,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,wBAAsB,gCAAgC,CACpD,YAAY,EAAE,sBAAsB,EAAE,EACtC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,oBAAoB,CAAC,CAiD/B;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,sBAAsB,EAAE,EACtC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,oBAAoB,CAAC,CAU/B"}

package/src/utils/solana.ts

@@ -1,100 +0,0 @@
-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");
-}