@openfort/openfort-js 0.8.26 → 0.8.27

package/README.md

@@ -12,8 +12,8 @@
       API Docs
     </a>
     <span> | </span>
-    <a href="https://twitter.com/openfortxyz">
-      Twitter
+    <a href="https://x.com/openfortxyz">
+      X
     </a>
   </h4>
 </div>
@@ -48,7 +48,7 @@ The Session Signer allows you to use external signing keys, without needing to p
 ```typescript
 const sessionKey = sdk.configureSessionKey();
 ```
-- **Register Key and Send Signature Session Request**: If `sessionKey.isRegistered` boolean is false, register the key from the backend. Refer to the documentation for [session management](https://www.openfort.xyz/docs/guides/accounts/smart/session-keys).
+- **Register Key and Send Signature Session Request**: If `sessionKey.isRegistered` boolean is false, register the key from the backend. Refer to the documentation for [session keys](https://www.openfort.xyz/docs/guides/javascript/smart-wallet/advanced/session-keys).
 - **Send Signature Transaction Intent Request**: When calling sendSignatureTransactionIntentRequest, pass the transaction intent ID and the user operation hash. The session signer will handle the signing.
 
 ### 2. External Sign
@@ -75,7 +75,7 @@ The Embedded Signer uses SSS to manage the private key on the client side. To le
   // using automatic recovery
   await sdk.configureEmbeddedSigner(chainId, shieldAuth);
 ```
-For now the only two recovery method available are the `PasswordRecovery` and `AutomaticRecovery`. Learn more about the [recovery methods](https://www.openfort.xyz/docs/guides/auth/embedded-signer/recovery).
+For now the only two recovery method available are the `PasswordRecovery` and `AutomaticRecovery`. Learn more about the [recovery methods](https://www.openfort.xyz/docs/guides/javascript/embedded-signer/recovery).
 - **Send Signature Transaction Intent Request**: Similar to the session signer, pass the transaction intent ID and the user operation hash. The embedded signer reconstructs the key and signs the transaction.
 ```typescript
 const response = await sdk.sendSignatureTransactionIntentRequest("transactionIntentId", "userOp");

package/dist/index.cjs

@@ -3492,7 +3492,7 @@ class KeyPair extends signingKey.SigningKey {
     }
 }
 
-const VERSION = '0.8.26';
+const VERSION = '0.8.27';
 
 var Event;
 (function (Event) {
@@ -4157,15 +4157,8 @@ const withOpenfortError = async (fn, customErrorType) => {
             const statusCode = error.response?.status;
             errorType = statusCode ? customErrorType[statusCode] || customErrorType.default : customErrorType.default;
             if (error.response?.data && error.response.data.error) {
-                const jsonData = JSON.parse(JSON.stringify(error.response.data.error));
-                // eslint-disable-next-line no-restricted-syntax
-                for (const key in jsonData) {
-                    if (key !== 'message' && key !== 'type') {
-                        data[key] = jsonData[key];
-                    }
-                }
-                if (isAPIError(error.response.data)) {
-                    errorMessage = error.response.data.message;
+                if (isAPIError(error.response.data.error)) {
+                    errorMessage = error.response.data.error.message;
                 }
                 else {
                     errorMessage = error.message;
@@ -5077,69 +5070,6 @@ class JsonRpcError extends Error {
     }
 }
 
-const buildOpenfortTransactions$4 = async (transactionRequest, backendApiClients, account, authentication, policyId) => {
-    const interactions = transactionRequest.map((tx) => {
-        if (!tx.to) {
-            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
-        }
-        return {
-            to: String(tx.to),
-            data: tx.data ? String(tx.data) : undefined,
-            value: tx.value ? String(tx.value) : undefined,
-        };
-    });
-    const transactionResponse = await backendApiClients.transactionIntentsApi.createTransactionIntent({
-        createTransactionIntentRequest: {
-            policy: policyId,
-            chainId: account.chainId,
-            interactions,
-        },
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
-};
-const sendTransaction = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
-    const openfortTransaction = await buildOpenfortTransactions$4(params, backendClient, account, authentication, policyId);
-    let response;
-    if (openfortTransaction?.nextAction?.payload?.signableHash) {
-        let signature;
-        // zkSync based chains need a different signature
-        if ([300, 531050104, 324, 50104, 2741, 11124].includes(account.chainId)) {
-            signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash, false, false);
-        }
-        else {
-            signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
-        }
-        const openfortSignatureResponse = (await backendClient.transactionIntentsApi.signature({
-            id: openfortTransaction.id,
-            signatureRequest: { signature },
-        })).data.response;
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-        }
-        response = openfortSignatureResponse;
-    }
-    else if (openfortTransaction.response) {
-        response = openfortTransaction.response;
-    }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.status === 0 && !response.transactionHash) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.error.reason);
-    }
-    return response.transactionHash;
-};
-
 const REQUIRED_TYPED_DATA_PROPERTIES = ['types', 'domain', 'primaryType', 'message'];
 const isValidTypedDataPayload = (typedData) => (REQUIRED_TYPED_DATA_PROPERTIES.every((key) => key in typedData));
 const transformTypedData = (typedData, chainId) => {
@@ -6712,20 +6642,23 @@ const buildOpenfortTransactions$3 = async (params, backendApiClients, account, a
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Failed to request permissions - missing session address');
     }
     const sessionRequest = formatSessionRequest$1(sessionAddress, account.chainId, now, expiry, policyId, false, whitelist, authentication.player, limit);
-    const transactionResponse = await backendApiClients.sessionsApi.createSession({
-        createSessionRequest: sessionRequest,
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
+    return withOpenfortError(async () => {
+        const response = await backendApiClients.sessionsApi.createSession({
+            createSessionRequest: sessionRequest,
+        }, {
+            headers: {
+                authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': authentication.token,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-auth-provider': authentication.thirdPartyProvider,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-token-type': authentication.thirdPartyTokenType,
+            },
+        });
+        return response.data;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+    }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
 };
 function formatRequest(result) {
     return {
@@ -6747,8 +6680,9 @@ function formatRequest(result) {
     };
 }
 const registerSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
-    const openfortTransaction = await buildOpenfortTransactions$3(params, backendClient, account, authentication, policyId);
-    let response;
+    const openfortTransaction = await buildOpenfortTransactions$3(params, backendClient, account, authentication, policyId).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         let signature;
         // zkSync based chains need a different signature
@@ -6761,19 +6695,15 @@ const registerSession = async ({ params, signer, account, authentication, backen
         const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
             id: openfortTransaction.id,
             signatureRequest: { signature },
+        }).catch((error) => {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
         });
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-        }
-        response = openfortSignatureResponse.data;
+        return formatRequest(openfortSignatureResponse.data);
     }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.isActive === false) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
+    if (openfortTransaction.isActive === false) {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Failed to grant permissions');
     }
-    return formatRequest(response);
+    return formatRequest(openfortTransaction);
 };
 
 const formatSessionRequest = (address, chainId, player, policyId) => {
@@ -6788,20 +6718,23 @@ const formatSessionRequest = (address, chainId, player, policyId) => {
 };
 const buildOpenfortTransactions$2 = async (params, backendApiClients, account, authentication, policyId) => {
     const sessionRequest = formatSessionRequest(params.permissionContext, account.chainId, authentication.player, policyId);
-    const transactionResponse = await backendApiClients.sessionsApi.revokeSession({
-        revokeSessionRequest: sessionRequest,
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
+    return withOpenfortError(async () => {
+        const response = await backendApiClients.sessionsApi.revokeSession({
+            revokeSessionRequest: sessionRequest,
+        }, {
+            headers: {
+                authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': authentication.token,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-auth-provider': authentication.thirdPartyProvider,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-token-type': authentication.thirdPartyTokenType,
+            },
+        });
+        return response.data;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+    }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
 };
 const revokeSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
     const param = params[0];
@@ -6809,8 +6742,9 @@ const revokeSession = async ({ params, signer, account, authentication, backendC
         await signer.logout();
         return {};
     }
-    const openfortTransaction = await buildOpenfortTransactions$2(param, backendClient, account, authentication, policyId);
-    let response;
+    const openfortTransaction = await buildOpenfortTransactions$2(param, backendClient, account, authentication, policyId).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         let signature;
         // zkSync based chains need a different signature
@@ -6823,19 +6757,12 @@ const revokeSession = async ({ params, signer, account, authentication, backendC
         const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
             id: openfortTransaction.id,
             signatureRequest: { signature },
+        }).catch((error) => {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
         });
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-        }
-        response = openfortSignatureResponse.data;
+        return openfortSignatureResponse.data;
     }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.isActive === false) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
-    }
-    return {};
+    return openfortTransaction;
 };
 
 const buildOpenfortTransactions$1 = async (calls, backendApiClients, account, authentication, policyId) => {
@@ -6849,29 +6776,33 @@ const buildOpenfortTransactions$1 = async (calls, backendApiClients, account, au
             value: call.value ? String(call.value) : undefined,
         };
     });
-    const transactionResponse = await backendApiClients.transactionIntentsApi.createTransactionIntent({
-        createTransactionIntentRequest: {
-            policy: policyId,
-            chainId: account.chainId,
-            interactions,
-        },
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
+    return withOpenfortError(async () => {
+        const response = await backendApiClients.transactionIntentsApi.createTransactionIntent({
+            createTransactionIntentRequest: {
+                policy: policyId,
+                chainId: account.chainId,
+                interactions,
+            },
+        }, {
+            headers: {
+                authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': authentication.token,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-auth-provider': authentication.thirdPartyProvider,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-token-type': authentication.thirdPartyTokenType,
+            },
+        });
+        return response.data;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+    }, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
 };
 const sendCalls = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
     const policy = params[0]?.capabilities?.paymasterService?.policy ?? policyId;
-    const openfortTransaction = await buildOpenfortTransactions$1(params[0].calls, backendClient, account, authentication, policy);
-    let response;
+    const openfortTransaction = await buildOpenfortTransactions$1(params, backendClient, account, authentication, policy).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         let signature;
         // zkSync based chains need a different signature
@@ -6881,29 +6812,25 @@ const sendCalls = async ({ params, signer, account, authentication, backendClien
         else {
             signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
         }
-        const openfortSignatureResponse = (await backendClient.transactionIntentsApi.signature({
+        const response = await backendClient.transactionIntentsApi.signature({
             id: openfortTransaction.id,
             signatureRequest: { signature },
-        })).data.response;
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }).catch((error) => {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+        });
+        if (response.data.response?.error) {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, response.data.response.error.reason);
         }
-        response = openfortSignatureResponse;
-    }
-    else if (openfortTransaction.response) {
-        response = openfortTransaction.response;
-    }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.status === 0 && !response.transactionHash) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.error.reason);
+        if (response.data.response?.status === 0) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.data.response?.error.reason);
+        }
+        return response.data.response?.transactionHash;
     }
-    return response.transactionHash;
+    return openfortTransaction.response?.transactionHash;
 };
 
-const buildOpenfortTransactions = async (transactionIntentId, backendApiClients, authentication) => {
-    const transactionResponse = await backendApiClients.transactionIntentsApi.getTransactionIntent({
+const buildOpenfortTransactions = async (transactionIntentId, backendApiClients, authentication) => withOpenfortError(async () => {
+    const response = await backendApiClients.transactionIntentsApi.getTransactionIntent({
         id: transactionIntentId,
     }, {
         headers: {
@@ -6916,10 +6843,13 @@ const buildOpenfortTransactions = async (transactionIntentId, backendApiClients,
             'x-token-type': authentication.thirdPartyTokenType,
         },
     });
-    return transactionResponse.data;
-};
+    return response.data;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+}, { default: exports.OpenfortErrorType.AUTHENTICATION_ERROR });
 const getCallStatus = async ({ params, authentication, backendClient, }) => {
-    const transactionIntent = await buildOpenfortTransactions(params[0], backendClient, authentication);
+    const transactionIntent = await buildOpenfortTransactions(params[0], backendClient, authentication).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     return {
         status: !transactionIntent.response ? 'PENDING' : 'CONFIRMED',
         receipts: transactionIntent.response
@@ -7023,7 +6953,7 @@ class EvmProvider {
                     throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
                 }
                 this.#validateAndRefreshSession();
-                return await sendTransaction({
+                return await sendCalls({
                     params: request.params || [],
                     signer,
                     account,
@@ -7128,7 +7058,7 @@ class EvmProvider {
                 }
                 this.#validateAndRefreshSession();
                 return await sendCalls({
-                    params: request.params || [],
+                    params: request.params ? request.params[0].calls : [],
                     signer,
                     account,
                     authentication,

package/dist/index.js

@@ -3469,7 +3469,7 @@ class KeyPair extends SigningKey {
     }
 }
 
-const VERSION = '0.8.26';
+const VERSION = '0.8.27';
 
 var Event;
 (function (Event) {
@@ -4134,15 +4134,8 @@ const withOpenfortError = async (fn, customErrorType) => {
             const statusCode = error.response?.status;
             errorType = statusCode ? customErrorType[statusCode] || customErrorType.default : customErrorType.default;
             if (error.response?.data && error.response.data.error) {
-                const jsonData = JSON.parse(JSON.stringify(error.response.data.error));
-                // eslint-disable-next-line no-restricted-syntax
-                for (const key in jsonData) {
-                    if (key !== 'message' && key !== 'type') {
-                        data[key] = jsonData[key];
-                    }
-                }
-                if (isAPIError(error.response.data)) {
-                    errorMessage = error.response.data.message;
+                if (isAPIError(error.response.data.error)) {
+                    errorMessage = error.response.data.error.message;
                 }
                 else {
                     errorMessage = error.message;
@@ -5054,69 +5047,6 @@ class JsonRpcError extends Error {
     }
 }
 
-const buildOpenfortTransactions$4 = async (transactionRequest, backendApiClients, account, authentication, policyId) => {
-    const interactions = transactionRequest.map((tx) => {
-        if (!tx.to) {
-            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
-        }
-        return {
-            to: String(tx.to),
-            data: tx.data ? String(tx.data) : undefined,
-            value: tx.value ? String(tx.value) : undefined,
-        };
-    });
-    const transactionResponse = await backendApiClients.transactionIntentsApi.createTransactionIntent({
-        createTransactionIntentRequest: {
-            policy: policyId,
-            chainId: account.chainId,
-            interactions,
-        },
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
-};
-const sendTransaction = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
-    const openfortTransaction = await buildOpenfortTransactions$4(params, backendClient, account, authentication, policyId);
-    let response;
-    if (openfortTransaction?.nextAction?.payload?.signableHash) {
-        let signature;
-        // zkSync based chains need a different signature
-        if ([300, 531050104, 324, 50104, 2741, 11124].includes(account.chainId)) {
-            signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash, false, false);
-        }
-        else {
-            signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
-        }
-        const openfortSignatureResponse = (await backendClient.transactionIntentsApi.signature({
-            id: openfortTransaction.id,
-            signatureRequest: { signature },
-        })).data.response;
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-        }
-        response = openfortSignatureResponse;
-    }
-    else if (openfortTransaction.response) {
-        response = openfortTransaction.response;
-    }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.status === 0 && !response.transactionHash) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.error.reason);
-    }
-    return response.transactionHash;
-};
-
 const REQUIRED_TYPED_DATA_PROPERTIES = ['types', 'domain', 'primaryType', 'message'];
 const isValidTypedDataPayload = (typedData) => (REQUIRED_TYPED_DATA_PROPERTIES.every((key) => key in typedData));
 const transformTypedData = (typedData, chainId) => {
@@ -6689,20 +6619,23 @@ const buildOpenfortTransactions$3 = async (params, backendApiClients, account, a
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Failed to request permissions - missing session address');
     }
     const sessionRequest = formatSessionRequest$1(sessionAddress, account.chainId, now, expiry, policyId, false, whitelist, authentication.player, limit);
-    const transactionResponse = await backendApiClients.sessionsApi.createSession({
-        createSessionRequest: sessionRequest,
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
+    return withOpenfortError(async () => {
+        const response = await backendApiClients.sessionsApi.createSession({
+            createSessionRequest: sessionRequest,
+        }, {
+            headers: {
+                authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': authentication.token,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-auth-provider': authentication.thirdPartyProvider,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-token-type': authentication.thirdPartyTokenType,
+            },
+        });
+        return response.data;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+    }, { default: OpenfortErrorType.AUTHENTICATION_ERROR });
 };
 function formatRequest(result) {
     return {
@@ -6724,8 +6657,9 @@ function formatRequest(result) {
     };
 }
 const registerSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
-    const openfortTransaction = await buildOpenfortTransactions$3(params, backendClient, account, authentication, policyId);
-    let response;
+    const openfortTransaction = await buildOpenfortTransactions$3(params, backendClient, account, authentication, policyId).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         let signature;
         // zkSync based chains need a different signature
@@ -6738,19 +6672,15 @@ const registerSession = async ({ params, signer, account, authentication, backen
         const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
             id: openfortTransaction.id,
             signatureRequest: { signature },
+        }).catch((error) => {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
         });
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-        }
-        response = openfortSignatureResponse.data;
+        return formatRequest(openfortSignatureResponse.data);
     }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.isActive === false) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
+    if (openfortTransaction.isActive === false) {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Failed to grant permissions');
     }
-    return formatRequest(response);
+    return formatRequest(openfortTransaction);
 };
 
 const formatSessionRequest = (address, chainId, player, policyId) => {
@@ -6765,20 +6695,23 @@ const formatSessionRequest = (address, chainId, player, policyId) => {
 };
 const buildOpenfortTransactions$2 = async (params, backendApiClients, account, authentication, policyId) => {
     const sessionRequest = formatSessionRequest(params.permissionContext, account.chainId, authentication.player, policyId);
-    const transactionResponse = await backendApiClients.sessionsApi.revokeSession({
-        revokeSessionRequest: sessionRequest,
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
+    return withOpenfortError(async () => {
+        const response = await backendApiClients.sessionsApi.revokeSession({
+            revokeSessionRequest: sessionRequest,
+        }, {
+            headers: {
+                authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': authentication.token,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-auth-provider': authentication.thirdPartyProvider,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-token-type': authentication.thirdPartyTokenType,
+            },
+        });
+        return response.data;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+    }, { default: OpenfortErrorType.AUTHENTICATION_ERROR });
 };
 const revokeSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
     const param = params[0];
@@ -6786,8 +6719,9 @@ const revokeSession = async ({ params, signer, account, authentication, backendC
         await signer.logout();
         return {};
     }
-    const openfortTransaction = await buildOpenfortTransactions$2(param, backendClient, account, authentication, policyId);
-    let response;
+    const openfortTransaction = await buildOpenfortTransactions$2(param, backendClient, account, authentication, policyId).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         let signature;
         // zkSync based chains need a different signature
@@ -6800,19 +6734,12 @@ const revokeSession = async ({ params, signer, account, authentication, backendC
         const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
             id: openfortTransaction.id,
             signatureRequest: { signature },
+        }).catch((error) => {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
         });
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-        }
-        response = openfortSignatureResponse.data;
+        return openfortSignatureResponse.data;
     }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.isActive === false) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
-    }
-    return {};
+    return openfortTransaction;
 };
 
 const buildOpenfortTransactions$1 = async (calls, backendApiClients, account, authentication, policyId) => {
@@ -6826,29 +6753,33 @@ const buildOpenfortTransactions$1 = async (calls, backendApiClients, account, au
             value: call.value ? String(call.value) : undefined,
         };
     });
-    const transactionResponse = await backendApiClients.transactionIntentsApi.createTransactionIntent({
-        createTransactionIntentRequest: {
-            policy: policyId,
-            chainId: account.chainId,
-            interactions,
-        },
-    }, {
-        headers: {
-            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-player-token': authentication.token,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-auth-provider': authentication.thirdPartyProvider,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'x-token-type': authentication.thirdPartyTokenType,
-        },
-    });
-    return transactionResponse.data;
+    return withOpenfortError(async () => {
+        const response = await backendApiClients.transactionIntentsApi.createTransactionIntent({
+            createTransactionIntentRequest: {
+                policy: policyId,
+                chainId: account.chainId,
+                interactions,
+            },
+        }, {
+            headers: {
+                authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-player-token': authentication.token,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-auth-provider': authentication.thirdPartyProvider,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'x-token-type': authentication.thirdPartyTokenType,
+            },
+        });
+        return response.data;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+    }, { default: OpenfortErrorType.AUTHENTICATION_ERROR });
 };
 const sendCalls = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
     const policy = params[0]?.capabilities?.paymasterService?.policy ?? policyId;
-    const openfortTransaction = await buildOpenfortTransactions$1(params[0].calls, backendClient, account, authentication, policy);
-    let response;
+    const openfortTransaction = await buildOpenfortTransactions$1(params, backendClient, account, authentication, policy).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         let signature;
         // zkSync based chains need a different signature
@@ -6858,29 +6789,25 @@ const sendCalls = async ({ params, signer, account, authentication, backendClien
         else {
             signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
         }
-        const openfortSignatureResponse = (await backendClient.transactionIntentsApi.signature({
+        const response = await backendClient.transactionIntentsApi.signature({
             id: openfortTransaction.id,
             signatureRequest: { signature },
-        })).data.response;
-        if (!openfortSignatureResponse) {
-            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }).catch((error) => {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+        });
+        if (response.data.response?.error) {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, response.data.response.error.reason);
         }
-        response = openfortSignatureResponse;
-    }
-    else if (openfortTransaction.response) {
-        response = openfortTransaction.response;
-    }
-    else {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
-    }
-    if (response.status === 0 && !response.transactionHash) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.error.reason);
+        if (response.data.response?.status === 0) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.data.response?.error.reason);
+        }
+        return response.data.response?.transactionHash;
     }
-    return response.transactionHash;
+    return openfortTransaction.response?.transactionHash;
 };
 
-const buildOpenfortTransactions = async (transactionIntentId, backendApiClients, authentication) => {
-    const transactionResponse = await backendApiClients.transactionIntentsApi.getTransactionIntent({
+const buildOpenfortTransactions = async (transactionIntentId, backendApiClients, authentication) => withOpenfortError(async () => {
+    const response = await backendApiClients.transactionIntentsApi.getTransactionIntent({
         id: transactionIntentId,
     }, {
         headers: {
@@ -6893,10 +6820,13 @@ const buildOpenfortTransactions = async (transactionIntentId, backendApiClients,
             'x-token-type': authentication.thirdPartyTokenType,
         },
     });
-    return transactionResponse.data;
-};
+    return response.data;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+}, { default: OpenfortErrorType.AUTHENTICATION_ERROR });
 const getCallStatus = async ({ params, authentication, backendClient, }) => {
-    const transactionIntent = await buildOpenfortTransactions(params[0], backendClient, authentication);
+    const transactionIntent = await buildOpenfortTransactions(params[0], backendClient, authentication).catch((error) => {
+        throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, error.message);
+    });
     return {
         status: !transactionIntent.response ? 'PENDING' : 'CONFIRMED',
         receipts: transactionIntent.response
@@ -7000,7 +6930,7 @@ class EvmProvider {
                     throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
                 }
                 this.#validateAndRefreshSession();
-                return await sendTransaction({
+                return await sendCalls({
                     params: request.params || [],
                     signer,
                     account,
@@ -7105,7 +7035,7 @@ class EvmProvider {
                 }
                 this.#validateAndRefreshSession();
                 return await sendCalls({
-                    params: request.params || [],
+                    params: request.params ? request.params[0].calls : [],
                     signer,
                     account,
                     authentication,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/openfort-js",
-  "version": "0.8.26",
+  "version": "0.8.27",
   "author": "Openfort (https://www.openfort.xyz)",
   "bugs": "https://github.com/openfort-xyz/openfort-js/issues",
   "repository": "openfort-xyz/openfort-js.git",