@dynamic-labs/global-wallet-client 4.9.8 → 4.9.9

package/src/lib/functions/createPopupOpener/createPopupOpener.cjs

@@ -5,80 +5,148 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../../../_virtual/_tslib.cjs');
 var utils = require('@dynamic-labs/utils');
-var waitForPopupResponse = require('../waitForPopupResponse/waitForPopupResponse.cjs');
 var onPopupClose = require('../onPopupClose/onPopupClose.cjs');
-var mergeAndEncryptParams = require('../mergeAndEncryptParams/mergeAndEncryptParams.cjs');
 var getCenteredPopupFeatures = require('../getCenteredPopupFeatures/getCenteredPopupFeatures.cjs');
+var createPopupMessageClient = require('../createPopupMessageClient/createPopupMessageClient.cjs');
+var createEncryptedMessageEncoder = require('../createEncryptedMessageEncoder/createEncryptedMessageEncoder.cjs');
+var PopupClosedError = require('../../errors/PopupClosedError.cjs');
+var mapErrorFromPopup = require('./utils/mapErrorFromPopup.cjs');
 
 const createPopupOpener = ({ environmentId, popupUrl, popupWidth = 420, popupHeight = 640, store, popupActionTimeout = 1000, // Wait page up to 1 second for new actions before closing
- }) => {
+onError, }) => {
     let popup = null;
-    let didOpenPopup = false;
     let lastActionId = null;
+    let clientSessionKeyPair = null;
     const closePopup = () => {
         popup === null || popup === void 0 ? void 0 : popup.close();
         popup = null;
-        didOpenPopup = false;
         lastActionId = null;
     };
+    // TODO update definition here to use name and args
     return (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ params, pathname, }) {
+        clientSessionKeyPair = clientSessionKeyPair !== null && clientSessionKeyPair !== void 0 ? clientSessionKeyPair : (yield utils.createKeyPair());
         // Used as a unique identifier for the action
-        const actionId = new Date().getTime();
+        const actionId = new Date().getTime().toString();
         lastActionId = actionId;
         const popupFinalUrl = new URL(popupUrl);
         const activeConnection = store.getActiveConnection();
-        const resultDeferredPromise = new utils.DeferredPromise();
         // Setup popup URL and data
-        popupFinalUrl.hash = `/${pathname}`;
         popupFinalUrl.searchParams.set('provider_env_id', environmentId);
-        // TODO: use PlatformService
         popupFinalUrl.searchParams.set('requester_origin', window.location.origin);
-        if (popup === null) {
+        popupFinalUrl.searchParams.set('client_session_public_key', yield utils.convertPublicKeyCryptoKeyToHex(clientSessionKeyPair.publicKey));
+        /**
+         * Open a new popup centered on the screen
+         */
+        const initializePopup = () => {
             const features = getCenteredPopupFeatures.getCenteredPopupFeatures({
                 height: popupHeight,
                 width: popupWidth,
             });
             // Open popup
-            popup = window.open('', '_blank', features);
-        }
-        // Encrypt params if active connection is present
-        if (params) {
-            yield mergeAndEncryptParams.mergeAndEncryptParams(popupFinalUrl, params, activeConnection);
-        }
-        if (popup === null) {
-            throw new Error('Failed to open popup');
-        }
-        waitForPopupResponse.waitForPopupResponse({
-            decode: (data) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-                if (activeConnection && utils.isEncryptedMessage(data)) {
-                    const decryptedData = yield utils.decryptMessage(activeConnection.sharedSecret, data.encryptedMessage, data.iv);
-                    return JSON.parse(decryptedData);
-                }
-                return data;
-            }),
-            onError: (error) => resultDeferredPromise.reject(error),
-            onResponse: (response) => resultDeferredPromise.resolve(response.data),
-            popupUrl: popupFinalUrl.toString(),
+            const popup = window.open('', '_blank', features);
+            if (popup === null) {
+                throw new Error('Failed to open popup');
+            }
+            popup.location = popupFinalUrl.href;
+            return popup;
+        };
+        /**
+         * Perform the initial handshake with the popup to get the session public key and nonce
+         */
+        const popupHandshake = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            utils.assertDefined(clientSessionKeyPair, 'Client session key pair is not set');
+            utils.assertDefined(popup, 'Popup is not defined');
+            const popupMessageClient = createPopupMessageClient.createPopupMessageClient(popup, popupFinalUrl.origin);
+            const [[popupSessionPublicKey], [nonce]] = yield Promise.all([
+                popupMessageClient.waitForMessage('sendPopupSessionPublicKey', 20000),
+                popupMessageClient.waitForMessage('sendPopupNonce', 20000),
+            ]);
+            const sessionSharedSecret = yield utils.deriveSharedSecret(clientSessionKeyPair.privateKey, yield utils.convertPublicKeyHexToCryptoKey(popupSessionPublicKey));
+            store.setSessionAuthCode(new TextEncoder().encode(yield utils.generateHMAC(sessionSharedSecret, nonce)));
         });
-        onPopupClose.onPopupClose(popup, () => {
-            resultDeferredPromise.reject(new Error('Popup closed'));
+        /**
+         * Watch for the popup to close
+         */
+        const watchForPopupClose = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            utils.assertDefined(popup, 'Popup is not defined');
+            return new Promise((_, reject) => {
+                utils.assertDefined(popup, 'Popup is not defined');
+                onPopupClose.onPopupClose(popup, () => {
+                    reject(new PopupClosedError.PopupClosedError());
+                });
+            });
+        });
+        /**
+         * Wait for the action response from the popup
+         */
+        const waitForActionResponse = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            utils.assertDefined(popup, 'Popup is not defined');
+            utils.assertDefined(store.sessionAuthCode, 'Session auth code is not set');
+            const resultDeferredPromise = new utils.DeferredPromise();
+            /**
+             * Recreate the popup message if the encryption is available
+             */
+            const encoder = activeConnection
+                ? createEncryptedMessageEncoder.createEncryptedMessageEncoder(activeConnection, store.sessionAuthCode)
+                : undefined;
+            const popupMessageClient = createPopupMessageClient.createPopupMessageClient(popup, popupFinalUrl.origin, encoder);
+            void popupMessageClient.postMessage('sendAction', {
+                id: actionId,
+                name: pathname,
+                params,
+            });
+            /**
+             * Listen for action resolved
+             */
+            const cleanUpActionResolvedListener = popupMessageClient.listenForMessage('actionResolved', ({ data, id }) => {
+                if (id === actionId) {
+                    resultDeferredPromise.resolve(data);
+                }
+            });
+            /**
+             * Listen for action rejected
+             */
+            const cleanUpActionRejectedListener = popupMessageClient.listenForMessage('actionRejected', ({ serializedError, id }) => {
+                if (id !== actionId)
+                    return;
+                resultDeferredPromise.reject(mapErrorFromPopup.mapErrorFromPopup(serializedError));
+            });
+            /**
+             * Listen for a global error
+             */
+            const cleanUpSendErrorListener = popupMessageClient.listenForMessage('sendError', (serializedError) => resultDeferredPromise.reject(mapErrorFromPopup.mapErrorFromPopup(serializedError)));
+            return resultDeferredPromise.promise.finally(() => {
+                cleanUpActionResolvedListener();
+                cleanUpActionRejectedListener();
+                cleanUpSendErrorListener();
+            });
         });
+        // This array will contain all parallel promises
+        const promises = [];
         /**
-         * Assign action to popup
+         * If no popup is present, it means this is a fresh new popup
+         * This block will create a new popup, perform the handshake and wait for the action response
          */
-        if (didOpenPopup) {
-            popup === null || popup === void 0 ? void 0 : popup.postMessage({
-                actionPath: popupFinalUrl.search + popupFinalUrl.hash,
-                event: 'new-action',
-            }, popupFinalUrl.origin);
+        if (popup === null) {
+            popup = initializePopup();
+            promises.push(watchForPopupClose());
+            promises.push(popupHandshake().then(waitForActionResponse));
         }
         else {
-            // Load popup
-            popup.location = popupFinalUrl.href;
+            /**
+             * If a popup is present, it means this is a re-use of the same popup
+             * This block will watch for the popup to close and wait for the action response
+             */
+            promises.push(watchForPopupClose());
+            promises.push(waitForActionResponse());
         }
-        didOpenPopup = true;
-        return resultDeferredPromise.promise
+        /**
+         * Return the promise and setup the popup cleanup
+         * and error handling
+         */
+        return Promise.race(promises)
             .catch((err) => {
+            onError === null || onError === void 0 ? void 0 : onError(err);
             closePopup();
             throw err;
         })

package/src/lib/functions/createPopupOpener/createPopupOpener.d.ts

@@ -7,11 +7,12 @@ type CreatePopupOpenerProps = {
     popupHeight?: number;
     store: ClientStore;
     popupActionTimeout?: number;
+    onError?: (error: Error) => void;
 };
 type OpenPopupProps<TAction extends IPopupAction> = {
     params: GetPopupActionFuncArgs<TAction>;
     pathname: GetPopupActionName<TAction>;
 };
-export declare const createPopupOpener: ({ environmentId, popupUrl, popupWidth, popupHeight, store, popupActionTimeout, }: CreatePopupOpenerProps) => <TPopupAction extends IPopupAction>({ params, pathname, }: OpenPopupProps<TPopupAction>) => Promise<GetPopupActionResult<TPopupAction>>;
+export declare const createPopupOpener: ({ environmentId, popupUrl, popupWidth, popupHeight, store, popupActionTimeout, onError, }: CreatePopupOpenerProps) => <TPopupAction extends IPopupAction>({ params, pathname, }: OpenPopupProps<TPopupAction>) => Promise<GetPopupActionResult<TPopupAction>>;
 export type OpenPopup = ReturnType<typeof createPopupOpener>;
 export {};

package/src/lib/functions/createPopupOpener/createPopupOpener.js

@@ -1,80 +1,148 @@
 'use client'
 import { __awaiter } from '../../../../_virtual/_tslib.js';
-import { DeferredPromise, isEncryptedMessage, decryptMessage } from '@dynamic-labs/utils';
-import { waitForPopupResponse } from '../waitForPopupResponse/waitForPopupResponse.js';
+import { createKeyPair, convertPublicKeyCryptoKeyToHex, assertDefined, deriveSharedSecret, convertPublicKeyHexToCryptoKey, generateHMAC, DeferredPromise } from '@dynamic-labs/utils';
 import { onPopupClose } from '../onPopupClose/onPopupClose.js';
-import { mergeAndEncryptParams } from '../mergeAndEncryptParams/mergeAndEncryptParams.js';
 import { getCenteredPopupFeatures } from '../getCenteredPopupFeatures/getCenteredPopupFeatures.js';
+import { createPopupMessageClient } from '../createPopupMessageClient/createPopupMessageClient.js';
+import { createEncryptedMessageEncoder } from '../createEncryptedMessageEncoder/createEncryptedMessageEncoder.js';
+import { PopupClosedError } from '../../errors/PopupClosedError.js';
+import { mapErrorFromPopup } from './utils/mapErrorFromPopup.js';
 
 const createPopupOpener = ({ environmentId, popupUrl, popupWidth = 420, popupHeight = 640, store, popupActionTimeout = 1000, // Wait page up to 1 second for new actions before closing
- }) => {
+onError, }) => {
     let popup = null;
-    let didOpenPopup = false;
     let lastActionId = null;
+    let clientSessionKeyPair = null;
     const closePopup = () => {
         popup === null || popup === void 0 ? void 0 : popup.close();
         popup = null;
-        didOpenPopup = false;
         lastActionId = null;
     };
+    // TODO update definition here to use name and args
     return (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, pathname, }) {
+        clientSessionKeyPair = clientSessionKeyPair !== null && clientSessionKeyPair !== void 0 ? clientSessionKeyPair : (yield createKeyPair());
         // Used as a unique identifier for the action
-        const actionId = new Date().getTime();
+        const actionId = new Date().getTime().toString();
         lastActionId = actionId;
         const popupFinalUrl = new URL(popupUrl);
         const activeConnection = store.getActiveConnection();
-        const resultDeferredPromise = new DeferredPromise();
         // Setup popup URL and data
-        popupFinalUrl.hash = `/${pathname}`;
         popupFinalUrl.searchParams.set('provider_env_id', environmentId);
-        // TODO: use PlatformService
         popupFinalUrl.searchParams.set('requester_origin', window.location.origin);
-        if (popup === null) {
+        popupFinalUrl.searchParams.set('client_session_public_key', yield convertPublicKeyCryptoKeyToHex(clientSessionKeyPair.publicKey));
+        /**
+         * Open a new popup centered on the screen
+         */
+        const initializePopup = () => {
             const features = getCenteredPopupFeatures({
                 height: popupHeight,
                 width: popupWidth,
             });
             // Open popup
-            popup = window.open('', '_blank', features);
-        }
-        // Encrypt params if active connection is present
-        if (params) {
-            yield mergeAndEncryptParams(popupFinalUrl, params, activeConnection);
-        }
-        if (popup === null) {
-            throw new Error('Failed to open popup');
-        }
-        waitForPopupResponse({
-            decode: (data) => __awaiter(void 0, void 0, void 0, function* () {
-                if (activeConnection && isEncryptedMessage(data)) {
-                    const decryptedData = yield decryptMessage(activeConnection.sharedSecret, data.encryptedMessage, data.iv);
-                    return JSON.parse(decryptedData);
-                }
-                return data;
-            }),
-            onError: (error) => resultDeferredPromise.reject(error),
-            onResponse: (response) => resultDeferredPromise.resolve(response.data),
-            popupUrl: popupFinalUrl.toString(),
+            const popup = window.open('', '_blank', features);
+            if (popup === null) {
+                throw new Error('Failed to open popup');
+            }
+            popup.location = popupFinalUrl.href;
+            return popup;
+        };
+        /**
+         * Perform the initial handshake with the popup to get the session public key and nonce
+         */
+        const popupHandshake = () => __awaiter(void 0, void 0, void 0, function* () {
+            assertDefined(clientSessionKeyPair, 'Client session key pair is not set');
+            assertDefined(popup, 'Popup is not defined');
+            const popupMessageClient = createPopupMessageClient(popup, popupFinalUrl.origin);
+            const [[popupSessionPublicKey], [nonce]] = yield Promise.all([
+                popupMessageClient.waitForMessage('sendPopupSessionPublicKey', 20000),
+                popupMessageClient.waitForMessage('sendPopupNonce', 20000),
+            ]);
+            const sessionSharedSecret = yield deriveSharedSecret(clientSessionKeyPair.privateKey, yield convertPublicKeyHexToCryptoKey(popupSessionPublicKey));
+            store.setSessionAuthCode(new TextEncoder().encode(yield generateHMAC(sessionSharedSecret, nonce)));
         });
-        onPopupClose(popup, () => {
-            resultDeferredPromise.reject(new Error('Popup closed'));
+        /**
+         * Watch for the popup to close
+         */
+        const watchForPopupClose = () => __awaiter(void 0, void 0, void 0, function* () {
+            assertDefined(popup, 'Popup is not defined');
+            return new Promise((_, reject) => {
+                assertDefined(popup, 'Popup is not defined');
+                onPopupClose(popup, () => {
+                    reject(new PopupClosedError());
+                });
+            });
+        });
+        /**
+         * Wait for the action response from the popup
+         */
+        const waitForActionResponse = () => __awaiter(void 0, void 0, void 0, function* () {
+            assertDefined(popup, 'Popup is not defined');
+            assertDefined(store.sessionAuthCode, 'Session auth code is not set');
+            const resultDeferredPromise = new DeferredPromise();
+            /**
+             * Recreate the popup message if the encryption is available
+             */
+            const encoder = activeConnection
+                ? createEncryptedMessageEncoder(activeConnection, store.sessionAuthCode)
+                : undefined;
+            const popupMessageClient = createPopupMessageClient(popup, popupFinalUrl.origin, encoder);
+            void popupMessageClient.postMessage('sendAction', {
+                id: actionId,
+                name: pathname,
+                params,
+            });
+            /**
+             * Listen for action resolved
+             */
+            const cleanUpActionResolvedListener = popupMessageClient.listenForMessage('actionResolved', ({ data, id }) => {
+                if (id === actionId) {
+                    resultDeferredPromise.resolve(data);
+                }
+            });
+            /**
+             * Listen for action rejected
+             */
+            const cleanUpActionRejectedListener = popupMessageClient.listenForMessage('actionRejected', ({ serializedError, id }) => {
+                if (id !== actionId)
+                    return;
+                resultDeferredPromise.reject(mapErrorFromPopup(serializedError));
+            });
+            /**
+             * Listen for a global error
+             */
+            const cleanUpSendErrorListener = popupMessageClient.listenForMessage('sendError', (serializedError) => resultDeferredPromise.reject(mapErrorFromPopup(serializedError)));
+            return resultDeferredPromise.promise.finally(() => {
+                cleanUpActionResolvedListener();
+                cleanUpActionRejectedListener();
+                cleanUpSendErrorListener();
+            });
         });
+        // This array will contain all parallel promises
+        const promises = [];
         /**
-         * Assign action to popup
+         * If no popup is present, it means this is a fresh new popup
+         * This block will create a new popup, perform the handshake and wait for the action response
          */
-        if (didOpenPopup) {
-            popup === null || popup === void 0 ? void 0 : popup.postMessage({
-                actionPath: popupFinalUrl.search + popupFinalUrl.hash,
-                event: 'new-action',
-            }, popupFinalUrl.origin);
+        if (popup === null) {
+            popup = initializePopup();
+            promises.push(watchForPopupClose());
+            promises.push(popupHandshake().then(waitForActionResponse));
         }
         else {
-            // Load popup
-            popup.location = popupFinalUrl.href;
+            /**
+             * If a popup is present, it means this is a re-use of the same popup
+             * This block will watch for the popup to close and wait for the action response
+             */
+            promises.push(watchForPopupClose());
+            promises.push(waitForActionResponse());
         }
-        didOpenPopup = true;
-        return resultDeferredPromise.promise
+        /**
+         * Return the promise and setup the popup cleanup
+         * and error handling
+         */
+        return Promise.race(promises)
             .catch((err) => {
+            onError === null || onError === void 0 ? void 0 : onError(err);
             closePopup();
             throw err;
         })

package/src/lib/functions/createPopupOpener/utils/mapErrorFromPopup.cjs

@@ -0,0 +1,25 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var messageTransport = require('@dynamic-labs/message-transport');
+var DisconnectError = require('../../../errors/DisconnectError.cjs');
+var UnknownError = require('../../../errors/UnknownError.cjs');
+
+const mapErrorFromPopup = (serializedError) => {
+    if (messageTransport.isSerializedError(serializedError)) {
+        const error = messageTransport.parseErrorFromTransport(serializedError);
+        if (DisconnectError.DisconnectError.isDisconnectError(error)) {
+            return new DisconnectError.DisconnectError();
+        }
+        else {
+            return error;
+        }
+    }
+    else {
+        return new UnknownError.UnknownError();
+    }
+};
+
+exports.mapErrorFromPopup = mapErrorFromPopup;

package/src/lib/functions/createPopupOpener/utils/mapErrorFromPopup.d.ts

@@ -0,0 +1,4 @@
+import { SerializedError } from '@dynamic-labs/message-transport';
+import { DisconnectError } from '../../../errors/DisconnectError';
+import { UnknownError } from '../../../errors/UnknownError';
+export declare const mapErrorFromPopup: (serializedError: SerializedError) => DisconnectError | unknown[] | UnknownError;

package/src/lib/functions/createPopupOpener/utils/mapErrorFromPopup.js

@@ -0,0 +1,21 @@
+'use client'
+import { isSerializedError, parseErrorFromTransport } from '@dynamic-labs/message-transport';
+import { DisconnectError } from '../../../errors/DisconnectError.js';
+import { UnknownError } from '../../../errors/UnknownError.js';
+
+const mapErrorFromPopup = (serializedError) => {
+    if (isSerializedError(serializedError)) {
+        const error = parseErrorFromTransport(serializedError);
+        if (DisconnectError.isDisconnectError(error)) {
+            return new DisconnectError();
+        }
+        else {
+            return error;
+        }
+    }
+    else {
+        return new UnknownError();
+    }
+};
+
+export { mapErrorFromPopup };

package/src/lib/solana/errors/UserRejectedRequestError.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class UserRejectedRequestError extends Error {
+    constructor() {
+        super('User rejected the request.');
+        this.code = 4001;
+    }
+}
+
+exports.UserRejectedRequestError = UserRejectedRequestError;

package/src/lib/solana/errors/UserRejectedRequestError.d.ts

@@ -0,0 +1,4 @@
+export declare class UserRejectedRequestError extends Error {
+    code: number;
+    constructor();
+}

package/src/lib/solana/errors/UserRejectedRequestError.js

@@ -0,0 +1,9 @@
+'use client'
+class UserRejectedRequestError extends Error {
+    constructor() {
+        super('User rejected the request.');
+        this.code = 4001;
+    }
+}
+
+export { UserRejectedRequestError };

package/src/lib/solana/functions/convertErrorToStandard/convertErrorToStandard.cjs

@@ -0,0 +1,17 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DisconnectError = require('../../../errors/DisconnectError.cjs');
+var PopupClosedError = require('../../../errors/PopupClosedError.cjs');
+var UserRejectedRequestError = require('../../errors/UserRejectedRequestError.cjs');
+
+const convertErrorToStandard = (error) => {
+    if (error instanceof PopupClosedError.PopupClosedError || error instanceof DisconnectError.DisconnectError) {
+        throw new UserRejectedRequestError.UserRejectedRequestError();
+    }
+    throw error;
+};
+
+exports.convertErrorToStandard = convertErrorToStandard;

package/src/lib/solana/functions/convertErrorToStandard/convertErrorToStandard.d.ts

@@ -0,0 +1 @@
+export declare const convertErrorToStandard: (error: unknown) => never;

package/src/lib/solana/functions/convertErrorToStandard/convertErrorToStandard.js

@@ -0,0 +1,13 @@
+'use client'
+import { DisconnectError } from '../../../errors/DisconnectError.js';
+import { PopupClosedError } from '../../../errors/PopupClosedError.js';
+import { UserRejectedRequestError } from '../../errors/UserRejectedRequestError.js';
+
+const convertErrorToStandard = (error) => {
+    if (error instanceof PopupClosedError || error instanceof DisconnectError) {
+        throw new UserRejectedRequestError();
+    }
+    throw error;
+};
+
+export { convertErrorToStandard };

package/src/lib/solana/functions/convertErrorToStandard/index.d.ts

@@ -0,0 +1 @@
+export { convertErrorToStandard } from './convertErrorToStandard';

package/src/lib/solana/functions/createSolanaSignAndSendTransactionFeature/createSolanaSignAndSendTransactionFeature.cjs

@@ -5,17 +5,20 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../../../../_virtual/_tslib.cjs');
 var utils = require('@dynamic-labs/utils');
+var convertErrorToStandard = require('../convertErrorToStandard/convertErrorToStandard.cjs');
 
 const createSolanaSignAndSendTransactionFeature = (client) => ({
     signAndSendTransaction: (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ account, transaction, chain }) {
-        const { signature } = yield client.invoke({
+        const { signature } = yield client
+            .invoke({
             params: {
                 address: account.address,
                 chain: chain,
                 transaction: utils.uint8ArrayToBase64(transaction),
             },
             pathname: 'solana_signAndSendTransaction',
-        });
+        })
+            .catch(convertErrorToStandard.convertErrorToStandard);
         return [
             {
                 signature: new TextEncoder().encode(signature),

package/src/lib/solana/functions/createSolanaSignAndSendTransactionFeature/createSolanaSignAndSendTransactionFeature.js

@@ -1,17 +1,20 @@
 'use client'
 import { __awaiter } from '../../../../../_virtual/_tslib.js';
 import { uint8ArrayToBase64 } from '@dynamic-labs/utils';
+import { convertErrorToStandard } from '../convertErrorToStandard/convertErrorToStandard.js';
 
 const createSolanaSignAndSendTransactionFeature = (client) => ({
     signAndSendTransaction: (_a) => __awaiter(void 0, [_a], void 0, function* ({ account, transaction, chain }) {
-        const { signature } = yield client.invoke({
+        const { signature } = yield client
+            .invoke({
             params: {
                 address: account.address,
                 chain: chain,
                 transaction: uint8ArrayToBase64(transaction),
             },
             pathname: 'solana_signAndSendTransaction',
-        });
+        })
+            .catch(convertErrorToStandard);
         return [
             {
                 signature: new TextEncoder().encode(signature),

package/src/lib/solana/functions/createSolanaSignMessageFeature/createSolanaSignMessageFeature.cjs

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../../../../_virtual/_tslib.cjs');
 var utils = require('@dynamic-labs/utils');
+var convertErrorToStandard = require('../convertErrorToStandard/convertErrorToStandard.cjs');
 
 const createSolanaSignMessageFeature = (client) => ({
     signMessage: (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ account, message }) {
@@ -12,10 +13,12 @@ const createSolanaSignMessageFeature = (client) => ({
             address: account.address,
             message: utils.uint8ArrayToBase64(message),
         };
-        const { signature, signedMessage } = yield client.invoke({
+        const { signature, signedMessage } = yield client
+            .invoke({
             params,
             pathname: 'solana_signMessage',
-        });
+        })
+            .catch(convertErrorToStandard.convertErrorToStandard);
         return [
             {
                 signature: utils.uint8ArrayFromBase64(signature),

package/src/lib/solana/functions/createSolanaSignMessageFeature/createSolanaSignMessageFeature.js

@@ -1,6 +1,7 @@
 'use client'
 import { __awaiter } from '../../../../../_virtual/_tslib.js';
 import { uint8ArrayToBase64, uint8ArrayFromBase64 } from '@dynamic-labs/utils';
+import { convertErrorToStandard } from '../convertErrorToStandard/convertErrorToStandard.js';
 
 const createSolanaSignMessageFeature = (client) => ({
     signMessage: (_a) => __awaiter(void 0, [_a], void 0, function* ({ account, message }) {
@@ -8,10 +9,12 @@ const createSolanaSignMessageFeature = (client) => ({
             address: account.address,
             message: uint8ArrayToBase64(message),
         };
-        const { signature, signedMessage } = yield client.invoke({
+        const { signature, signedMessage } = yield client
+            .invoke({
             params,
             pathname: 'solana_signMessage',
-        });
+        })
+            .catch(convertErrorToStandard);
         return [
             {
                 signature: uint8ArrayFromBase64(signature),

package/src/lib/solana/functions/createSolanaSignTransactionFeature/createSolanaSignTransactionFeature.cjs

@@ -5,17 +5,20 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../../../../_virtual/_tslib.cjs');
 var utils = require('@dynamic-labs/utils');
+var convertErrorToStandard = require('../convertErrorToStandard/convertErrorToStandard.cjs');
 
 const createSolanaSignTransactionFeature = (client) => ({
     signTransaction: (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ account, transaction, chain }) {
-        const { signedTransaction } = yield client.invoke({
+        const { signedTransaction } = yield client
+            .invoke({
             params: {
                 address: account.address,
                 chain: chain,
                 transaction: utils.uint8ArrayToBase64(transaction),
             },
             pathname: 'solana_signTransaction',
-        });
+        })
+            .catch(convertErrorToStandard.convertErrorToStandard);
         return [
             {
                 signedTransaction: utils.uint8ArrayFromBase64(signedTransaction),