e2e solana signMessage w/o unlock & approve origin

packages/provider-core/src/provider-solana.ts

@@ -43,7 +43,7 @@ import type {
   VersionedTransaction,
 } from "@solana/web3.js";
 import { Connection, PublicKey } from "@solana/web3.js";
-import { encode } from "bs58";
+import { decode, encode } from "bs58";
 
 import { PrivateEventEmitter } from "./common/PrivateEventEmitter";
 import * as cmn from "./common/solana";
@@ -91,6 +91,7 @@ export class ProviderSolanaInjection
     this.#secureSolanaClient = new SolanaClient(
       new FromContentScriptTransportSender(),
       {
+        context: "web",
         name: document.title,
         address: window.location.origin,
       }
@@ -397,13 +398,16 @@ export class ProviderSolanaInjection
       publicKey: (publicKey ?? this.#publicKey).toString(),
       message: encode(msg),
     });
-    console.log("PCA", solanaResponse);
-
-    return await cmn.signMessage(
-      publicKey ?? this.#publicKey,
-      this.#requestManager,
-      msg
-    );
+    if (!solanaResponse) {
+      throw new Error("signature failed");
+    }
+    return decode(solanaResponse);
+    // nocommit
+    // return await cmn.signMessage(
+    //   publicKey ?? this.#publicKey,
+    //   this.#requestManager,
+    //   msg
+    // );
   }
 
   public get isBackpack() {

packages/secure-background/clients.ts

@@ -8,3 +8,4 @@ export {
   mockTransportReceiver,
   mockTransportSender,
 } from "./src/transports/mockTransports";
+export { TransportResponder } from "./src/transports/TransportResponder";

packages/secure-background/src/keyring/blockchain.ts

@@ -280,7 +280,7 @@ export class BlockchainKeyring {
     walletAddress: string
   ): Promise<string> {
     const keyring = this.getKeyring(walletAddress);
-    const msgBuffer = Buffer.from(decode(msg));
+    const msgBuffer = Buffer.from(msg);
     return keyring.signMessage(msgBuffer, walletAddress);
   }
 

packages/secure-background/src/services/evm/client.ts

@@ -4,16 +4,14 @@ import type {
   TransportSender,
 } from "../../types/transports";
 
-import type { SECURE_EVM_EVENTS, SECURE_EVM_SIGN_MESSAGE } from "./events";
-
 export class EVMClient {
   constructor(
     private secureBackgroundClient: TransportSender,
     private origin: SecureEventOrigin
   ) {}
 
   public async signMessage(
-    request: SecureRequest<SECURE_EVM_SIGN_MESSAGE>["request"]
+    request: SecureRequest<"SECURE_EVM_SIGN_MESSAGE">["request"]
   ) {
     await this.secureBackgroundClient.send({
       name: "SECURE_EVM_SIGN_MESSAGE",

packages/secure-background/src/services/evm/server.ts

@@ -2,16 +2,13 @@ import type { KeyringStore } from "../../store/keyring";
 import type {
   SecureRequest,
   TransportHandler,
+  TransportHandlers,
   TransportReceiver,
   TransportRemoveListener,
   TransportSender,
 } from "../../types/transports";
 
-import type {
-  SECURE_EVM_EVENTS,
-  SECURE_EVM_SIGN_MESSAGE,
-  SECURE_EVM_SIGN_TX,
-} from "./events";
+import type { SECURE_EVM_EVENTS } from "./events";
 
 export class EVMService {
   public destroy: TransportRemoveListener;
@@ -25,21 +22,21 @@ export class EVMService {
   }
 
   private eventHandler: TransportHandler<SECURE_EVM_EVENTS> = (request) => {
-    switch (request.name) {
-      case "SECURE_EVM_SIGN_MESSAGE":
-        return this.handleSignMessage(request);
-      case "SECURE_EVM_SIGN_TX":
-        return this.handleSign(request);
-    }
-  };
+    const handlers: TransportHandlers<SECURE_EVM_EVENTS> = {
+      SECURE_EVM_SIGN_MESSAGE: this.handleSignMessage,
+      SECURE_EVM_SIGN_TX: this.handleSign,
+    };
 
-  private handleSignMessage: TransportHandler<SECURE_EVM_SIGN_MESSAGE> = async (
-    request
-  ) => {
-    throw "Not Implemented";
+    const handler = handlers[request.name]?.bind(this);
+    return handler && handler(request);
   };
 
-  private handleSign: TransportHandler<SECURE_EVM_SIGN_TX> = async (
+  private handleSignMessage: TransportHandler<"SECURE_EVM_SIGN_MESSAGE"> =
+    async (request) => {
+      throw "Not Implemented";
+    };
+
+  private handleSign: TransportHandler<"SECURE_EVM_SIGN_TX"> = async (
     request
   ) => {
     throw "Not Implemented";

packages/secure-background/src/services/svm/server.ts

@@ -1,29 +1,25 @@
 import { Blockchain } from "@coral-xyz/common";
 
 import type { KeyringStore } from "../../store/keyring";
+import type { SECURE_EVENTS } from "../../types/events";
 import type {
   TransportHandler,
+  TransportHandlers,
   TransportReceiver,
   TransportRemoveListener,
   TransportSender,
 } from "../../types/transports";
 import { SecureUIClient } from "../secureUI/client";
 
-import type {
-  SECURE_SVM_EVENTS,
-  SECURE_SVM_SAY_HELLO,
-  SECURE_SVM_SIGN_ALL_TX,
-  SECURE_SVM_SIGN_MESSAGE,
-  SECURE_SVM_SIGN_TX,
-} from "./events";
+import type { SECURE_SVM_EVENTS } from "./events";
 
 export class SVMService {
   public destroy: TransportRemoveListener;
   private secureUIClient: SecureUIClient;
   private keyringStore: KeyringStore;
 
   constructor(interfaces: {
-    secureReceiver: TransportReceiver<SECURE_SVM_EVENTS, "response">;
+    secureReceiver: TransportReceiver<SECURE_SVM_EVENTS>;
     keyringStore: KeyringStore;
     secureUISender: TransportSender<SECURE_SVM_EVENTS, "confirmation">;
   }) {
@@ -35,91 +31,66 @@ export class SVMService {
   }
 
   private eventHandler: TransportHandler<SECURE_SVM_EVENTS> = (request) => {
-    switch (request.name) {
-      case "SECURE_SVM_SIGN_MESSAGE":
-        return this.handleSignMessage(request);
-      case "SECURE_SVM_SIGN_TX":
-        return this.handleSign(request);
-      case "SECURE_SVM_SIGN_ALL_TX":
-        return this.handleSignAll(request);
-      case "SECURE_SVM_SAY_HELLO":
-        return this.handleHello(request);
-    }
+    const handlers: TransportHandlers<SECURE_SVM_EVENTS> = {
+      SECURE_SVM_SIGN_MESSAGE: this.handleSignMessage,
+      SECURE_SVM_SIGN_TX: this.handleSign,
+      SECURE_SVM_SIGN_ALL_TX: this.handleSignAll,
+      SECURE_SVM_SAY_HELLO: this.handleHello,
+    };
+
+    const handler = handlers[request.name]?.bind(this);
+    return handler && handler(request);
   };
 
-  private handleSignMessage: TransportHandler<SECURE_SVM_SIGN_MESSAGE> = async (
-    event
-  ) => {
-    console.log("PCA HANDLE sign message", event);
-    // const confirm = await this.secureUISender.send(request)
-    const confirmation = await this.secureUIClient.confirm(event);
-
-    console.log("PCA confirmation", confirmation);
-    if (confirmation.error || !confirmation.response?.confirmed) {
-      return {
-        name: "SECURE_SVM_SIGN_MESSAGE",
-        error: "User Denied Request",
-      };
-    }
-
-    const blockchainKeyring =
-      this.keyringStore.activeUserKeyring.keyringForBlockchain(
-        Blockchain.SOLANA
+  private handleSignMessage: TransportHandler<"SECURE_SVM_SIGN_MESSAGE"> =
+    async (event) => {
+      console.log("PCA HANDLE sign message", event);
+      // const confirm = await this.secureUISender.send(request)
+      const confirmation = await this.secureUIClient.confirm(event.event);
+
+      console.log("PCA confirmation", confirmation);
+      if (confirmation.error || !confirmation.response?.confirmed) {
+        return event.error("User Denied Request");
+      }
+
+      const blockchainKeyring =
+        this.keyringStore.activeUserKeyring.keyringForBlockchain(
+          Blockchain.SOLANA
+        );
+
+      if (blockchainKeyring.ledgerKeyring) {
+        // open ledger prompt
+      }
+
+      const singedMessage = await blockchainKeyring.signMessage(
+        event.request.message,
+        event.request.publicKey
       );
 
-    if (blockchainKeyring.ledgerKeyring) {
-      // open ledger prompt
-    }
+      if (blockchainKeyring.ledgerKeyring) {
+        // close ledger prompt
+      }
 
-    const singedMessage = await blockchainKeyring.signMessage(
-      event.request.message,
-      event.request.publicKey
-    );
-
-    if (blockchainKeyring.ledgerKeyring) {
-      // close ledger prompt
-    }
+      console.log("PCA responde to contentscript", singedMessage);
 
-    console.log("PCA responde to contentscript", singedMessage);
-
-    return {
-      name: "SECURE_SVM_SIGN_MESSAGE",
-      response: {
-        singedMessage,
-      },
+      return event.respond({ singedMessage });
     };
-  };
 
-  private handleSign: TransportHandler<SECURE_SVM_SIGN_TX> = async ({
-    request,
-  }) => {
-    return {
-      name: "SECURE_SVM_SIGN_TX",
-      response: {
-        signedTx: "string",
-      },
-    };
+  private handleSign: TransportHandler<"SECURE_SVM_SIGN_TX"> = async (
+    event
+  ) => {
+    return event.respond({ signedTx: "string" });
   };
 
-  private handleHello: TransportHandler<SECURE_SVM_SAY_HELLO> = async ({
-    request,
-  }) => {
-    return {
-      name: "SECURE_SVM_SAY_HELLO",
-      response: {
-        message: "hello " + request.name,
-      },
-    };
+  private handleHello: TransportHandler<"SECURE_SVM_SAY_HELLO"> = async (
+    event
+  ) => {
+    return event.respond({ message: "hello " + event.request.name });
   };
 
-  private handleSignAll: TransportHandler<SECURE_SVM_SIGN_ALL_TX> = async ({
-    request,
+  private handleSignAll: TransportHandler<"SECURE_SVM_SIGN_ALL_TX"> = async ({
+    respond,
   }) => {
-    return {
-      name: "SECURE_SVM_SIGN_ALL_TX",
-      response: {
-        signedTx: ["string"],
-      },
-    };
+    return respond({ signedTx: ["string"] });
   };
 }

packages/secure-background/src/services/user/server.ts

@@ -2,13 +2,14 @@ import type { KeyringStore } from "../../store/keyring";
 import { KeyringStoreStateEnum } from "../../store/keyring";
 import type {
   TransportHandler,
+  TransportHandlers,
   TransportReceiver,
   TransportRemoveListener,
   TransportSender,
 } from "../../types/transports";
 import { SecureUIClient } from "../secureUI/client";
 
-import type { SECURE_USER_EVENTS, SECURE_USER_UNLOCK_KEYRING } from "./events";
+import type { SECURE_USER_EVENTS } from "./events";
 
 export class UserService {
   public destroy: TransportRemoveListener;
@@ -27,56 +28,38 @@ export class UserService {
     );
   }
 
-  private eventHandler: TransportHandler<SECURE_USER_EVENTS> = (request) => {
-    switch (request.name) {
-      case "SECURE_USER_UNLOCK_KEYRING":
-        return this.handleUnlockKeyring(request);
-    }
+  private eventHandler: TransportHandler<SECURE_USER_EVENTS> = async (
+    request
+  ) => {
+    const handlers: TransportHandlers<SECURE_USER_EVENTS> = {
+      SECURE_USER_UNLOCK_KEYRING: this.handleUnlockKeyring,
+    };
+
+    const handler = handlers[request.name]?.bind(this);
+    return handler && handler(request);
   };
 
-  private handleUnlockKeyring: TransportHandler<SECURE_USER_UNLOCK_KEYRING> =
-    async (request) => {
+  private handleUnlockKeyring: TransportHandler<"SECURE_USER_UNLOCK_KEYRING"> =
+    async (event) => {
       const uuid =
-        request.request.uuid ?? this.keyringStore.activeUserKeyring?.uuid;
+        event.request.uuid ?? this.keyringStore.activeUserKeyring?.uuid;
       const keyringState = await this.keyringStore.state();
 
       if (
         keyringState === KeyringStoreStateEnum.Locked &&
-        request.request.password &&
+        event.request.password &&
         uuid
       ) {
         return this.keyringStore
           .tryUnlock({
-            password: request.request.password,
+            password: event.request.password,
             uuid: uuid,
           })
-          .then(() => {
-            return {
-              name: request.name,
-              response: {
-                unlocked: true,
-              },
-            };
-          })
-          .catch((e) => {
-            return {
-              name: request.name,
-              error: e,
-            };
-          });
+          .then(() => event.respond({ unlocked: true }))
+          .catch((e) => event.error(e));
       } else if (keyringState === KeyringStoreStateEnum.Unlocked) {
-        return {
-          name: request.name,
-          response: {
-            unlocked: true,
-          },
-        };
+        return event.respond({ unlocked: true });
       }
-      return {
-        name: request.name,
-        response: {
-          unlocked: false,
-        },
-      };
+      return event.respond({ unlocked: false });
     };
 }