[BUG] Correctly import new seed phrase

.github/workflows/runTests.yml

@@ -8,7 +8,7 @@ jobs:
     timeout-minutes: 20
     runs-on: ubuntu-latest
     container:
-      image: mcr.microsoft.com/playwright:v1.41.0-jammy
+      image: mcr.microsoft.com/playwright:v1.45.3-jammy
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4

@shared/api/external.ts

@@ -1,10 +1,16 @@
 import { EXTERNAL_SERVICE_TYPES } from "../constants/services";
 import { NetworkDetails } from "../constants/stellar";
-import { sendMessageToContentScript } from "./helpers/extensionMessaging";
-import { UserInfo } from "./types";
-
-export const requestAccess = async (): Promise<string> => {
-  let response = { publicKey: "", error: "" };
+import {
+  sendMessageToContentScript,
+  FreighterApiInternalError,
+} from "./helpers/extensionMessaging";
+import { FreighterApiError } from "./types";
+
+export const requestAccess = async (): Promise<{
+  publicKey: string;
+  error?: FreighterApiError;
+}> => {
+  let response;
   try {
     response = await sendMessageToContentScript({
       type: EXTERNAL_SERVICE_TYPES.REQUEST_ACCESS,
@@ -13,16 +19,16 @@ export const requestAccess = async (): Promise<string> => {
     console.error(e);
   }
 
-  const { publicKey, error } = response;
+  const { publicKey } = response || { publicKey: "" };
 
-  if (error) {
-    throw error;
-  }
-  return publicKey;
+  return { publicKey, error: response?.apiError };
 };
 
-export const requestPublicKey = async (): Promise<string> => {
-  let response = { publicKey: "", error: "" };
+export const requestPublicKey = async (): Promise<{
+  publicKey: string;
+  error?: FreighterApiError;
+}> => {
+  let response;
   try {
     response = await sendMessageToContentScript({
       type: EXTERNAL_SERVICE_TYPES.REQUEST_PUBLIC_KEY,
@@ -31,25 +37,23 @@ export const requestPublicKey = async (): Promise<string> => {
     console.error(e);
   }
 
-  const { publicKey, error } = response;
-
-  if (error) {
-    throw error;
-  }
-  return publicKey;
+  return { publicKey: response?.publicKey || "", error: response?.apiError };
 };
 
 export const submitTransaction = async (
   transactionXdr: string,
   opts?:
     | string
     | {
-        network?: string;
         accountToSign?: string;
         networkPassphrase?: string;
       },
   accountToSign?: string,
-): Promise<string> => {
+): Promise<{
+  signedTransaction: string;
+  signerAddress: string;
+  error?: FreighterApiError;
+}> => {
   let network = "";
   let _accountToSign = "";
   let networkPassphrase = "";
@@ -60,15 +64,14 @@ export const submitTransaction = async (
   This logic maintains backwards compatibility for older versions
   */
   if (typeof opts === "object") {
-    network = opts.network || "";
     _accountToSign = opts.accountToSign || "";
     networkPassphrase = opts.networkPassphrase || "";
   } else {
     network = opts || "";
     _accountToSign = accountToSign || "";
   }
 
-  let response = { signedTransaction: "", error: "" };
+  let response;
   try {
     response = await sendMessageToContentScript({
       transactionXdr,
@@ -78,127 +81,158 @@ export const submitTransaction = async (
       type: EXTERNAL_SERVICE_TYPES.SUBMIT_TRANSACTION,
     });
   } catch (e) {
-    console.error(e);
-    throw e;
+    return {
+      signedTransaction: "",
+      signerAddress: "",
+      error: FreighterApiInternalError,
+    };
   }
-  const { signedTransaction, error } = response;
+  const { signedTransaction, signerAddress } = response;
 
-  if (error) {
-    throw error;
-  }
-  return signedTransaction;
+  return { signedTransaction, signerAddress, error: response?.apiError };
 };
 
-export const submitBlob = async (
+export const submitMessage = async (
   blob: string,
   opts?: {
-    accountToSign?: string;
+    address?: string;
+    networkPassphrase?: string;
   },
-): Promise<string> => {
-  let response = { signedBlob: "", error: "" };
+): Promise<{
+  signedMessage: Buffer | null;
+  signerAddress: string;
+  error?: FreighterApiError;
+}> => {
+  let response;
   const _opts = opts || {};
-  const accountToSign = _opts.accountToSign || "";
+  const accountToSign = _opts.address || "";
   try {
     response = await sendMessageToContentScript({
       blob,
       accountToSign,
       type: EXTERNAL_SERVICE_TYPES.SUBMIT_BLOB,
     });
   } catch (e) {
-    console.error(e);
-    throw e;
+    return {
+      signedMessage: null,
+      signerAddress: "",
+      error: FreighterApiInternalError,
+    };
   }
-  const { signedBlob, error } = response;
+  const { signedBlob, signerAddress } = response;
 
-  if (error) {
-    throw error;
-  }
-  return signedBlob;
+  return {
+    signedMessage: signedBlob || null,
+    signerAddress,
+    error: response?.apiError,
+  };
 };
 
 export const submitAuthEntry = async (
   entryXdr: string,
   opts?: {
-    accountToSign?: string;
+    address?: string;
+    networkPassphrase?: string;
   },
-): Promise<string> => {
-  let response = { signedAuthEntry: "", error: "" };
+): Promise<{
+  signedAuthEntry: Buffer | null;
+  signerAddress: string;
+  error?: FreighterApiError;
+}> => {
   const _opts = opts || {};
-  const accountToSign = _opts.accountToSign || "";
+  const accountToSign = _opts.address || "";
+  let response;
   try {
     response = await sendMessageToContentScript({
       entryXdr,
       accountToSign,
+      networkPassphrase: opts?.networkPassphrase,
       type: EXTERNAL_SERVICE_TYPES.SUBMIT_AUTH_ENTRY,
     });
   } catch (e) {
     console.error(e);
+    return {
+      signedAuthEntry: null,
+      signerAddress: "",
+      error: FreighterApiInternalError,
+    };
   }
-  const { signedAuthEntry, error } = response;
+  const { signedAuthEntry, signerAddress } = response;
 
-  if (error) {
-    throw error;
-  }
-  return signedAuthEntry;
+  return {
+    signedAuthEntry: signedAuthEntry || null,
+    signerAddress,
+    error: response?.apiError,
+  };
 };
 
-export const requestNetwork = async (): Promise<string> => {
-  let response = { network: "", error: "" };
+export const requestNetwork = async (): Promise<{
+  network: string;
+  networkPassphrase: string;
+  error?: FreighterApiError;
+}> => {
+  let response;
   try {
     response = await sendMessageToContentScript({
-      type: EXTERNAL_SERVICE_TYPES.REQUEST_NETWORK,
+      type: EXTERNAL_SERVICE_TYPES.REQUEST_NETWORK_DETAILS,
     });
   } catch (e) {
     console.error(e);
   }
 
-  const { network, error } = response;
+  const { networkDetails } = response || {
+    networkDetails: { network: "", networkPassphrase: "" },
+  };
 
-  if (error) {
-    throw error;
-  }
-  return network;
+  return {
+    network: networkDetails?.network,
+    networkPassphrase: networkDetails?.networkPassphrase,
+    error: response?.apiError,
+  };
 };
 
 export const requestNetworkDetails = async (): Promise<{
   network: string;
   networkUrl: string;
   networkPassphrase: string;
   sorobanRpcUrl?: string;
+  error?: FreighterApiError;
 }> => {
-  let response = {
+  let response;
+  try {
+    response = await sendMessageToContentScript({
+      type: EXTERNAL_SERVICE_TYPES.REQUEST_NETWORK_DETAILS,
+    });
+  } catch (e) {
+    console.error(e);
+  }
+
+  const { networkDetails, apiError } = response || {
     networkDetails: {
       network: "",
       networkName: "",
       networkUrl: "",
       networkPassphrase: "",
       sorobanRpcUrl: undefined,
+      apiError: "",
     } as NetworkDetails,
-    error: "",
   };
-  try {
-    response = await sendMessageToContentScript({
-      type: EXTERNAL_SERVICE_TYPES.REQUEST_NETWORK_DETAILS,
-    });
-  } catch (e) {
-    console.error(e);
-  }
 
-  const { networkDetails, error } = response;
-  const {
+  const { network, networkUrl, networkPassphrase, sorobanRpcUrl } =
+    networkDetails;
+
+  return {
     network,
     networkUrl,
     networkPassphrase,
     sorobanRpcUrl,
-  } = networkDetails;
-
-  if (error) {
-    throw error;
-  }
-  return { network, networkUrl, networkPassphrase, sorobanRpcUrl };
+    error: apiError,
+  };
 };
 
-export const requestConnectionStatus = async (): Promise<boolean> => {
+export const requestConnectionStatus = async (): Promise<{
+  isConnected: boolean;
+}> => {
   let response = {
     isConnected: false,
   };
@@ -211,13 +245,14 @@ export const requestConnectionStatus = async (): Promise<boolean> => {
     console.error(e);
   }
 
-  return response.isConnected;
+  return { isConnected: response.isConnected };
 };
 
-export const requestAllowedStatus = async (): Promise<boolean> => {
-  let response = {
-    isAllowed: false,
-  };
+export const requestAllowedStatus = async (): Promise<{
+  isAllowed: boolean;
+  error?: FreighterApiError;
+}> => {
+  let response;
 
   try {
     response = await sendMessageToContentScript({
@@ -227,14 +262,16 @@ export const requestAllowedStatus = async (): Promise<boolean> => {
     console.error(e);
   }
 
-  return response.isAllowed;
+  const { isAllowed } = response || { isAllowed: false };
+
+  return { isAllowed, error: response?.apiError };
 };
 
-export const setAllowedStatus = async (): Promise<boolean> => {
-  let response = {
-    isAllowed: false,
-    error: "",
-  };
+export const setAllowedStatus = async (): Promise<{
+  isAllowed: boolean;
+  error?: FreighterApiError;
+}> => {
+  let response;
 
   try {
     response = await sendMessageToContentScript({
@@ -244,28 +281,9 @@ export const setAllowedStatus = async (): Promise<boolean> => {
     console.error(e);
   }
 
-  const { isAllowed, error } = response;
-
-  if (error) {
-    throw error;
-  }
-  return isAllowed;
-};
-
-export const requestUserInfo = async (): Promise<UserInfo> => {
-  let response = { userInfo: { publicKey: "" }, error: "" };
-  try {
-    response = await sendMessageToContentScript({
-      type: EXTERNAL_SERVICE_TYPES.REQUEST_USER_INFO,
-    });
-  } catch (e) {
-    console.error(e);
-  }
-
-  const { userInfo, error } = response;
+  const { isAllowed } = response || {
+    isAllowed: false,
+  };
 
-  if (error) {
-    throw error;
-  }
-  return userInfo;
+  return { isAllowed, error: response?.apiError };
 };