@portal-hq/provider 4.1.3 → 4.1.4

package/lib/commonjs/providers/index.js

@@ -44,7 +44,7 @@ class Provider {
     // Required
     apiKey, keychain, gatewayConfig, 
     // Optional
-    autoApprove = false, apiHost = 'api.portalhq.io', mpcHost = 'mpc.portalhq.io', version = 'v6', chainId = 'eip155:11155111', featureFlags = {}, }) {
+    autoApprove = false, apiHost = 'api.portalhq.io', mpcHost = 'mpc.portalhq.io', enclaveMPCHost = 'mpc-client.portalhq.io', version = 'v6', chainId = 'eip155:11155111', featureFlags = {}, }) {
         // Handle required fields
         if (!apiKey || apiKey.length === 0) {
             throw new utils_1.InvalidApiKeyError();
@@ -69,14 +69,26 @@ class Provider {
         });
         // Initialize Gateway HttpRequester
         this.gateway = new utils_1.PortalRequests();
-        // Initialize an MpcSigner
-        this.signer = new signers_1.MpcSigner({
-            mpcHost,
-            keychain,
-            version,
-            portalApi: this.portalApi,
-            featureFlags,
-        });
+        // Initialize the appropriate signer based on feature flags
+        if (featureFlags.useEnclaveMPCApi) {
+            this.signer = new signers_1.EnclaveSigner({
+                mpcHost,
+                enclaveMPCHost,
+                keychain,
+                version,
+                portalApi: this.portalApi,
+                featureFlags,
+            });
+        }
+        else {
+            this.signer = new signers_1.MpcSigner({
+                mpcHost,
+                keychain,
+                version,
+                portalApi: this.portalApi,
+                featureFlags,
+            });
+        }
     }
     /**
      * Invokes all registered event handlers with the data provided
@@ -282,8 +294,7 @@ class Provider {
         });
     }
     /**
-     * Updates the chainId of this instance and builds a new RPC HttpRequester for
-     * the gateway used for the new chain
+     * Updates the chainId of this instance
      *
      * @param chainId The numerical ID of the chain to switch to
      * @returns BaseProvider

package/lib/commonjs/signers/enclave.js

@@ -0,0 +1,316 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@portal-hq/core");
+const utils_1 = require("@portal-hq/utils");
+const react_native_uuid_1 = __importDefault(require("react-native-uuid"));
+var Operation;
+(function (Operation) {
+    Operation["SIGN"] = "sign";
+    Operation["RAW_SIGN"] = "raw_sign";
+})(Operation || (Operation = {}));
+class EnclaveSigner {
+    constructor({ keychain, enclaveMPCHost = 'mpc-client.portalhq.io', version = 'v6', portalApi, featureFlags = {}, }) {
+        this.version = 'v6';
+        this.buildParams = (method, txParams) => {
+            let params = txParams;
+            switch (method) {
+                case 'eth_sign':
+                case 'personal_sign':
+                case 'eth_signTypedData_v3':
+                case 'eth_signTypedData_v4':
+                case 'sol_signMessage':
+                case 'sol_signTransaction':
+                case 'sol_signAndSendTransaction':
+                case 'sol_signAndConfirmTransaction':
+                    if (!Array.isArray(txParams)) {
+                        params = [txParams];
+                    }
+                    break;
+                default:
+                    if (Array.isArray(txParams)) {
+                        if (txParams.length === 1) {
+                            params = txParams[0];
+                        }
+                    }
+            }
+            return params;
+        };
+        this.featureFlags = featureFlags;
+        this.keychain = keychain;
+        this.enclaveMPCHost = enclaveMPCHost;
+        this.version = version;
+        this.portalApi = portalApi;
+        this.requests = new utils_1.HttpRequester({
+            baseUrl: `https://${this.enclaveMPCHost}`,
+        });
+    }
+    sign(message, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Always track metrics, but only send if feature flag is enabled
+            const shouldSendMetrics = this.featureFlags.enableSdkPerformanceMetrics === true;
+            const signStartTime = performance.now();
+            const preOperationStartTime = performance.now();
+            // Generate a traceId for this operation
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            const traceId = react_native_uuid_1.default.v4();
+            const metrics = {
+                hasError: false,
+                operation: Operation.SIGN,
+                signingMethod: message.method,
+                traceId,
+            };
+            try {
+                const eip155Address = yield this.keychain.getEip155Address();
+                const apiKey = provider.apiKey;
+                const { method, chainId, curve, isRaw } = message;
+                // Add chainId to metrics
+                if (chainId) {
+                    metrics.chainId = chainId;
+                }
+                switch (method) {
+                    case 'eth_requestAccounts':
+                        return [eip155Address];
+                    case 'eth_accounts':
+                        return [eip155Address];
+                    default:
+                        break;
+                }
+                const shares = yield this.keychain.getShares();
+                let signingShare = shares.secp256k1.share;
+                if (curve === core_1.PortalCurve.ED25519) {
+                    if (!shares.ed25519) {
+                        throw new Error('[Portal.Provider.EnclaveSigner] The ED25519 share is missing from the keychain.');
+                    }
+                    signingShare = shares.ed25519.share;
+                }
+                const metadata = {
+                    clientPlatform: 'REACT_NATIVE',
+                    clientPlatformVersion: (0, utils_1.getClientPlatformVersion)(),
+                    isMultiBackupEnabled: this.featureFlags.isMultiBackupEnabled,
+                    mpcServerVersion: this.version,
+                    optimized: true,
+                    curve,
+                    chainId,
+                    isRaw,
+                    reqId: traceId,
+                    connectionTracingEnabled: shouldSendMetrics,
+                };
+                let formattedParams;
+                let rpcUrl;
+                if (isRaw) {
+                    formattedParams = JSON.stringify(this.buildParams(method, message.params));
+                    rpcUrl = '';
+                    metrics.operation = Operation.RAW_SIGN;
+                }
+                else {
+                    formattedParams = JSON.stringify(this.buildParams(method, message.params));
+                    rpcUrl = provider.getGatewayUrl(chainId);
+                }
+                if (typeof formattedParams !== 'string') {
+                    throw new Error(`[Portal.Provider.EnclaveSigner] The formatted params for the signing request could not be converted to a string. The params were: ${formattedParams}`);
+                }
+                // Record pre-operation time
+                metrics.sdkPreOperationMs = performance.now() - preOperationStartTime;
+                // Measure enclave signing operation time
+                const enclaveSignStartTime = performance.now();
+                const result = isRaw
+                    ? yield this.enclaveRawSign(apiKey, JSON.stringify(signingShare), formattedParams, curve || 'SECP256K1')
+                    : yield this.enclaveSign(apiKey, JSON.stringify(signingShare), message.method, formattedParams, rpcUrl, chainId || '', JSON.stringify(metadata));
+                // Post-operation processing time starts
+                const postOperationStartTime = performance.now();
+                // Record HTTP call time
+                metrics.enclaveHttpCallMs = performance.now() - enclaveSignStartTime;
+                // Record post-operation time
+                metrics.sdkPostOperationMs = performance.now() - postOperationStartTime;
+                // Calculate total SDK signing time
+                metrics.sdkOperationMs = performance.now() - signStartTime;
+                // Log performance timing to console
+                const timingMetrics = {};
+                if (typeof metrics.sdkPreOperationMs === 'number') {
+                    timingMetrics['Pre-operation'] = metrics.sdkPreOperationMs;
+                }
+                if (typeof metrics.enclaveHttpCallMs === 'number') {
+                    timingMetrics['Enclave HTTP Call'] = metrics.enclaveHttpCallMs;
+                }
+                if (typeof metrics.sdkPostOperationMs === 'number') {
+                    timingMetrics['Post-operation'] = metrics.sdkPostOperationMs;
+                }
+                // Only send metrics if the feature flag is enabled
+                if (shouldSendMetrics && this.portalApi) {
+                    try {
+                        yield this.sendMetrics(metrics, apiKey);
+                    }
+                    catch (err) {
+                        // No-op
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                // Calculate total time even in error case
+                metrics.sdkOperationMs = performance.now() - signStartTime;
+                // Log performance timing to console even in error case
+                const errorTimingMetrics = {};
+                if (typeof metrics.sdkPreOperationMs === 'number') {
+                    errorTimingMetrics['Pre-operation'] = metrics.sdkPreOperationMs;
+                }
+                // Only send metrics if the feature flag is enabled
+                if (shouldSendMetrics) {
+                    const apiKey = provider.apiKey;
+                    metrics.hasError = true;
+                    try {
+                        yield this.sendMetrics(metrics, apiKey);
+                    }
+                    catch (_a) {
+                        // No-op
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    enclaveRawSign(apiKey, signingShare, params, curve) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!apiKey || !signingShare || !params || !curve) {
+                return this.encodeErrorResult('INVALID_PARAMETERS', 'Invalid parameters provided for raw signing');
+            }
+            const requestBody = {
+                params: params,
+                share: signingShare,
+            };
+            const endpoint = `/v1/raw/sign/${curve}`;
+            try {
+                const response = yield this.requests.post(endpoint, {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: requestBody,
+                });
+                return this.encodeSuccessResult(response.data);
+            }
+            catch (error) {
+                if ((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                    const portalError = this.decodePortalError(JSON.stringify(error.response.data));
+                    return this.encodeErrorResult(portalError === null || portalError === void 0 ? void 0 : portalError.id, portalError === null || portalError === void 0 ? void 0 : portalError.message);
+                }
+                return this.encodeErrorResult('SIGNING_NETWORK_ERROR', 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+                error.message || 'Network error occurred');
+            }
+        });
+    }
+    enclaveSign(apiKey, signingShare, method, params, rpcURL, chainId, metadata) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!apiKey ||
+                !signingShare ||
+                !method ||
+                !params ||
+                !chainId ||
+                !metadata) {
+                return this.encodeErrorResult('INVALID_PARAMETERS', 'Invalid parameters provided');
+            }
+            const requestBody = {
+                method: method,
+                params: params,
+                share: signingShare,
+                chainId: chainId,
+                rpcUrl: rpcURL,
+                metadataStr: metadata,
+                clientPlatform: 'REACT_NATIVE',
+                clientPlatformVersion: (0, utils_1.getClientPlatformVersion)(),
+            };
+            try {
+                const response = yield this.requests.post('/v1/sign', {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: requestBody,
+                });
+                return this.encodeSuccessResult(response.data);
+            }
+            catch (error) {
+                if ((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                    const portalError = this.decodePortalError(JSON.stringify(error.response.data));
+                    return this.encodeErrorResult(portalError === null || portalError === void 0 ? void 0 : portalError.id, portalError === null || portalError === void 0 ? void 0 : portalError.message);
+                }
+                return this.encodeErrorResult('SIGNING_NETWORK_ERROR', 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+                error.message || 'Network error occurred');
+            }
+        });
+    }
+    // Helper function to encode success results
+    encodeSuccessResult(data) {
+        const successResult = { data: data, error: undefined };
+        return this.encodeJSON(successResult);
+    }
+    // Helper function to decode Portal errors
+    decodePortalError(errorStr) {
+        if (!errorStr)
+            return null;
+        try {
+            return JSON.parse(errorStr);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    // Helper function to encode error results
+    encodeErrorResult(id, message) {
+        const errorResult = {
+            data: undefined,
+            error: { id, message },
+        };
+        return this.encodeJSON(errorResult);
+    }
+    // Helper function to encode any object to JSON string
+    encodeJSON(value) {
+        try {
+            const jsonString = JSON.stringify(value);
+            return jsonString;
+        }
+        catch (error) {
+            return JSON.stringify({
+                error: {
+                    id: 'ENCODING_ERROR',
+                    message: `Failed to encode JSON: ${error.message}`,
+                },
+            });
+        }
+    }
+    sendMetrics(metrics, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.portalApi) {
+                    yield this.portalApi.post('/api/v3/clients/me/sdk/metrics', {
+                        headers: {
+                            Authorization: `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: metrics,
+                    });
+                }
+            }
+            catch (_a) {
+                // No-op
+            }
+        });
+    }
+}
+exports.default = EnclaveSigner;

package/lib/commonjs/signers/index.js

@@ -3,8 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MpcSigner = exports.Signer = void 0;
+exports.EnclaveSigner = exports.MpcSigner = exports.Signer = void 0;
 var abstract_1 = require("./abstract");
 Object.defineProperty(exports, "Signer", { enumerable: true, get: function () { return __importDefault(abstract_1).default; } });
 var mpc_1 = require("./mpc");
 Object.defineProperty(exports, "MpcSigner", { enumerable: true, get: function () { return __importDefault(mpc_1).default; } });
+var enclave_1 = require("./enclave");
+Object.defineProperty(exports, "EnclaveSigner", { enumerable: true, get: function () { return __importDefault(enclave_1).default; } });

package/lib/commonjs/signers/mpc.js

@@ -158,7 +158,7 @@ class MpcSigner {
                         metrics.sdkBinaryConnectMs = binaryMetrics.connectMs;
                     }
                 }
-                if ((error === null || error === void 0 ? void 0 : error.code) > 0) {
+                if (error === null || error === void 0 ? void 0 : error.id) {
                     throw new utils_1.PortalMpcError(error);
                 }
                 // Record post-operation time

package/lib/esm/providers/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { PortalCurve } from '@portal-hq/core';
 import { Events, HttpRequester, InvalidApiKeyError, InvalidGatewayConfigError, PortalRequests, ProviderRpcError, RpcErrorCodes, } from '@portal-hq/utils';
-import { MpcSigner } from '../signers';
+import { MpcSigner, EnclaveSigner } from '../signers';
 const passiveSignerMethods = [
     'eth_accounts',
     'eth_chainId',
@@ -42,7 +42,7 @@ class Provider {
     // Required
     apiKey, keychain, gatewayConfig, 
     // Optional
-    autoApprove = false, apiHost = 'api.portalhq.io', mpcHost = 'mpc.portalhq.io', version = 'v6', chainId = 'eip155:11155111', featureFlags = {}, }) {
+    autoApprove = false, apiHost = 'api.portalhq.io', mpcHost = 'mpc.portalhq.io', enclaveMPCHost = 'mpc-client.portalhq.io', version = 'v6', chainId = 'eip155:11155111', featureFlags = {}, }) {
         // Handle required fields
         if (!apiKey || apiKey.length === 0) {
             throw new InvalidApiKeyError();
@@ -67,14 +67,26 @@ class Provider {
         });
         // Initialize Gateway HttpRequester
         this.gateway = new PortalRequests();
-        // Initialize an MpcSigner
-        this.signer = new MpcSigner({
-            mpcHost,
-            keychain,
-            version,
-            portalApi: this.portalApi,
-            featureFlags,
-        });
+        // Initialize the appropriate signer based on feature flags
+        if (featureFlags.useEnclaveMPCApi) {
+            this.signer = new EnclaveSigner({
+                mpcHost,
+                enclaveMPCHost,
+                keychain,
+                version,
+                portalApi: this.portalApi,
+                featureFlags,
+            });
+        }
+        else {
+            this.signer = new MpcSigner({
+                mpcHost,
+                keychain,
+                version,
+                portalApi: this.portalApi,
+                featureFlags,
+            });
+        }
     }
     /**
      * Invokes all registered event handlers with the data provided
@@ -280,8 +292,7 @@ class Provider {
         });
     }
     /**
-     * Updates the chainId of this instance and builds a new RPC HttpRequester for
-     * the gateway used for the new chain
+     * Updates the chainId of this instance
      *
      * @param chainId The numerical ID of the chain to switch to
      * @returns BaseProvider

package/lib/esm/signers/enclave.js

@@ -0,0 +1,311 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PortalCurve } from '@portal-hq/core';
+import { HttpRequester, getClientPlatformVersion, } from '@portal-hq/utils';
+import UUID from 'react-native-uuid';
+var Operation;
+(function (Operation) {
+    Operation["SIGN"] = "sign";
+    Operation["RAW_SIGN"] = "raw_sign";
+})(Operation || (Operation = {}));
+class EnclaveSigner {
+    constructor({ keychain, enclaveMPCHost = 'mpc-client.portalhq.io', version = 'v6', portalApi, featureFlags = {}, }) {
+        this.version = 'v6';
+        this.buildParams = (method, txParams) => {
+            let params = txParams;
+            switch (method) {
+                case 'eth_sign':
+                case 'personal_sign':
+                case 'eth_signTypedData_v3':
+                case 'eth_signTypedData_v4':
+                case 'sol_signMessage':
+                case 'sol_signTransaction':
+                case 'sol_signAndSendTransaction':
+                case 'sol_signAndConfirmTransaction':
+                    if (!Array.isArray(txParams)) {
+                        params = [txParams];
+                    }
+                    break;
+                default:
+                    if (Array.isArray(txParams)) {
+                        if (txParams.length === 1) {
+                            params = txParams[0];
+                        }
+                    }
+            }
+            return params;
+        };
+        this.featureFlags = featureFlags;
+        this.keychain = keychain;
+        this.enclaveMPCHost = enclaveMPCHost;
+        this.version = version;
+        this.portalApi = portalApi;
+        this.requests = new HttpRequester({
+            baseUrl: `https://${this.enclaveMPCHost}`,
+        });
+    }
+    sign(message, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Always track metrics, but only send if feature flag is enabled
+            const shouldSendMetrics = this.featureFlags.enableSdkPerformanceMetrics === true;
+            const signStartTime = performance.now();
+            const preOperationStartTime = performance.now();
+            // Generate a traceId for this operation
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            const traceId = UUID.v4();
+            const metrics = {
+                hasError: false,
+                operation: Operation.SIGN,
+                signingMethod: message.method,
+                traceId,
+            };
+            try {
+                const eip155Address = yield this.keychain.getEip155Address();
+                const apiKey = provider.apiKey;
+                const { method, chainId, curve, isRaw } = message;
+                // Add chainId to metrics
+                if (chainId) {
+                    metrics.chainId = chainId;
+                }
+                switch (method) {
+                    case 'eth_requestAccounts':
+                        return [eip155Address];
+                    case 'eth_accounts':
+                        return [eip155Address];
+                    default:
+                        break;
+                }
+                const shares = yield this.keychain.getShares();
+                let signingShare = shares.secp256k1.share;
+                if (curve === PortalCurve.ED25519) {
+                    if (!shares.ed25519) {
+                        throw new Error('[Portal.Provider.EnclaveSigner] The ED25519 share is missing from the keychain.');
+                    }
+                    signingShare = shares.ed25519.share;
+                }
+                const metadata = {
+                    clientPlatform: 'REACT_NATIVE',
+                    clientPlatformVersion: getClientPlatformVersion(),
+                    isMultiBackupEnabled: this.featureFlags.isMultiBackupEnabled,
+                    mpcServerVersion: this.version,
+                    optimized: true,
+                    curve,
+                    chainId,
+                    isRaw,
+                    reqId: traceId,
+                    connectionTracingEnabled: shouldSendMetrics,
+                };
+                let formattedParams;
+                let rpcUrl;
+                if (isRaw) {
+                    formattedParams = JSON.stringify(this.buildParams(method, message.params));
+                    rpcUrl = '';
+                    metrics.operation = Operation.RAW_SIGN;
+                }
+                else {
+                    formattedParams = JSON.stringify(this.buildParams(method, message.params));
+                    rpcUrl = provider.getGatewayUrl(chainId);
+                }
+                if (typeof formattedParams !== 'string') {
+                    throw new Error(`[Portal.Provider.EnclaveSigner] The formatted params for the signing request could not be converted to a string. The params were: ${formattedParams}`);
+                }
+                // Record pre-operation time
+                metrics.sdkPreOperationMs = performance.now() - preOperationStartTime;
+                // Measure enclave signing operation time
+                const enclaveSignStartTime = performance.now();
+                const result = isRaw
+                    ? yield this.enclaveRawSign(apiKey, JSON.stringify(signingShare), formattedParams, curve || 'SECP256K1')
+                    : yield this.enclaveSign(apiKey, JSON.stringify(signingShare), message.method, formattedParams, rpcUrl, chainId || '', JSON.stringify(metadata));
+                // Post-operation processing time starts
+                const postOperationStartTime = performance.now();
+                // Record HTTP call time
+                metrics.enclaveHttpCallMs = performance.now() - enclaveSignStartTime;
+                // Record post-operation time
+                metrics.sdkPostOperationMs = performance.now() - postOperationStartTime;
+                // Calculate total SDK signing time
+                metrics.sdkOperationMs = performance.now() - signStartTime;
+                // Log performance timing to console
+                const timingMetrics = {};
+                if (typeof metrics.sdkPreOperationMs === 'number') {
+                    timingMetrics['Pre-operation'] = metrics.sdkPreOperationMs;
+                }
+                if (typeof metrics.enclaveHttpCallMs === 'number') {
+                    timingMetrics['Enclave HTTP Call'] = metrics.enclaveHttpCallMs;
+                }
+                if (typeof metrics.sdkPostOperationMs === 'number') {
+                    timingMetrics['Post-operation'] = metrics.sdkPostOperationMs;
+                }
+                // Only send metrics if the feature flag is enabled
+                if (shouldSendMetrics && this.portalApi) {
+                    try {
+                        yield this.sendMetrics(metrics, apiKey);
+                    }
+                    catch (err) {
+                        // No-op
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                // Calculate total time even in error case
+                metrics.sdkOperationMs = performance.now() - signStartTime;
+                // Log performance timing to console even in error case
+                const errorTimingMetrics = {};
+                if (typeof metrics.sdkPreOperationMs === 'number') {
+                    errorTimingMetrics['Pre-operation'] = metrics.sdkPreOperationMs;
+                }
+                // Only send metrics if the feature flag is enabled
+                if (shouldSendMetrics) {
+                    const apiKey = provider.apiKey;
+                    metrics.hasError = true;
+                    try {
+                        yield this.sendMetrics(metrics, apiKey);
+                    }
+                    catch (_a) {
+                        // No-op
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    enclaveRawSign(apiKey, signingShare, params, curve) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!apiKey || !signingShare || !params || !curve) {
+                return this.encodeErrorResult('INVALID_PARAMETERS', 'Invalid parameters provided for raw signing');
+            }
+            const requestBody = {
+                params: params,
+                share: signingShare,
+            };
+            const endpoint = `/v1/raw/sign/${curve}`;
+            try {
+                const response = yield this.requests.post(endpoint, {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: requestBody,
+                });
+                return this.encodeSuccessResult(response.data);
+            }
+            catch (error) {
+                if ((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                    const portalError = this.decodePortalError(JSON.stringify(error.response.data));
+                    return this.encodeErrorResult(portalError === null || portalError === void 0 ? void 0 : portalError.id, portalError === null || portalError === void 0 ? void 0 : portalError.message);
+                }
+                return this.encodeErrorResult('SIGNING_NETWORK_ERROR', 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+                error.message || 'Network error occurred');
+            }
+        });
+    }
+    enclaveSign(apiKey, signingShare, method, params, rpcURL, chainId, metadata) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!apiKey ||
+                !signingShare ||
+                !method ||
+                !params ||
+                !chainId ||
+                !metadata) {
+                return this.encodeErrorResult('INVALID_PARAMETERS', 'Invalid parameters provided');
+            }
+            const requestBody = {
+                method: method,
+                params: params,
+                share: signingShare,
+                chainId: chainId,
+                rpcUrl: rpcURL,
+                metadataStr: metadata,
+                clientPlatform: 'REACT_NATIVE',
+                clientPlatformVersion: getClientPlatformVersion(),
+            };
+            try {
+                const response = yield this.requests.post('/v1/sign', {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: requestBody,
+                });
+                return this.encodeSuccessResult(response.data);
+            }
+            catch (error) {
+                if ((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                    const portalError = this.decodePortalError(JSON.stringify(error.response.data));
+                    return this.encodeErrorResult(portalError === null || portalError === void 0 ? void 0 : portalError.id, portalError === null || portalError === void 0 ? void 0 : portalError.message);
+                }
+                return this.encodeErrorResult('SIGNING_NETWORK_ERROR', 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+                error.message || 'Network error occurred');
+            }
+        });
+    }
+    // Helper function to encode success results
+    encodeSuccessResult(data) {
+        const successResult = { data: data, error: undefined };
+        return this.encodeJSON(successResult);
+    }
+    // Helper function to decode Portal errors
+    decodePortalError(errorStr) {
+        if (!errorStr)
+            return null;
+        try {
+            return JSON.parse(errorStr);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    // Helper function to encode error results
+    encodeErrorResult(id, message) {
+        const errorResult = {
+            data: undefined,
+            error: { id, message },
+        };
+        return this.encodeJSON(errorResult);
+    }
+    // Helper function to encode any object to JSON string
+    encodeJSON(value) {
+        try {
+            const jsonString = JSON.stringify(value);
+            return jsonString;
+        }
+        catch (error) {
+            return JSON.stringify({
+                error: {
+                    id: 'ENCODING_ERROR',
+                    message: `Failed to encode JSON: ${error.message}`,
+                },
+            });
+        }
+    }
+    sendMetrics(metrics, apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.portalApi) {
+                    yield this.portalApi.post('/api/v3/clients/me/sdk/metrics', {
+                        headers: {
+                            Authorization: `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: metrics,
+                    });
+                }
+            }
+            catch (_a) {
+                // No-op
+            }
+        });
+    }
+}
+export default EnclaveSigner;

package/lib/esm/signers/index.js

@@ -1,2 +1,3 @@
 export { default as Signer } from './abstract';
 export { default as MpcSigner } from './mpc';
+export { default as EnclaveSigner } from './enclave';

package/lib/esm/signers/mpc.js

@@ -153,7 +153,7 @@ class MpcSigner {
                         metrics.sdkBinaryConnectMs = binaryMetrics.connectMs;
                     }
                 }
-                if ((error === null || error === void 0 ? void 0 : error.code) > 0) {
+                if (error === null || error === void 0 ? void 0 : error.id) {
                     throw new PortalMpcError(error);
                 }
                 // Record post-operation time

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portal-hq/provider",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -19,8 +19,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@portal-hq/connect": "^4.1.3",
-    "@portal-hq/utils": "^4.1.3",
+    "@portal-hq/connect": "^4.1.4",
+    "@portal-hq/utils": "^4.1.4",
     "@types/react-native-uuid": "^2.0.0",
     "react-native-uuid": "^2.0.3"
   },
@@ -32,5 +32,5 @@
     "ts-jest": "^29.0.3",
     "typescript": "^4.8.4"
   },
-  "gitHead": "912b03f1152f4dbb7e017919c63bdc950ca867cf"
+  "gitHead": "6507173bd858f430a4144bd9e700878a879cf286"
 }

package/src/providers/index.ts

@@ -21,8 +21,7 @@ import {
   type RegisteredEventHandler,
   SwitchEthereumChainParameter,
 } from '../../types'
-import { MpcSigner, Signer } from '../signers'
-
+import { MpcSigner, Signer, EnclaveSigner } from '../signers'
 const passiveSignerMethods = [
   'eth_accounts',
   'eth_chainId',
@@ -77,6 +76,7 @@ class Provider implements IPortalProvider {
     autoApprove = false,
     apiHost = 'api.portalhq.io',
     mpcHost = 'mpc.portalhq.io',
+    enclaveMPCHost = 'mpc-client.portalhq.io',
     version = 'v6',
     chainId = 'eip155:11155111',
     featureFlags = {},
@@ -110,14 +110,25 @@ class Provider implements IPortalProvider {
     // Initialize Gateway HttpRequester
     this.gateway = new PortalRequests()
 
-    // Initialize an MpcSigner
-    this.signer = new MpcSigner({
-      mpcHost,
-      keychain,
-      version,
-      portalApi: this.portalApi,
-      featureFlags,
-    })
+    // Initialize the appropriate signer based on feature flags
+    if (featureFlags.useEnclaveMPCApi) {
+      this.signer = new EnclaveSigner({
+        mpcHost,
+        enclaveMPCHost,
+        keychain,
+        version,
+        portalApi: this.portalApi,
+        featureFlags,
+      })
+    } else {
+      this.signer = new MpcSigner({
+        mpcHost,
+        keychain,
+        version,
+        portalApi: this.portalApi,
+        featureFlags,
+      })
+    }
   }
 
   /**
@@ -362,8 +373,7 @@ class Provider implements IPortalProvider {
     return result
   }
   /**
-   * Updates the chainId of this instance and builds a new RPC HttpRequester for
-   * the gateway used for the new chain
+   * Updates the chainId of this instance
    *
    * @param chainId The numerical ID of the chain to switch to
    * @returns BaseProvider

package/src/signers/enclave.ts

@@ -0,0 +1,414 @@
+import { PortalCurve } from '@portal-hq/core'
+import { FeatureFlags } from '@portal-hq/core/types'
+import {
+  HttpRequester,
+  IPortalProvider,
+  KeychainAdapter,
+  type SigningRequestArguments,
+  getClientPlatformVersion,
+} from '@portal-hq/utils'
+import UUID from 'react-native-uuid'
+
+import {
+  type MpcSignerOptions,
+  PortalMobileMpcMetadata,
+  type EnclaveSignRequest,
+  type EnclaveSignResponse,
+  type EnclaveSignResult,
+} from '../../types'
+import Signer from './abstract'
+
+enum Operation {
+  SIGN = 'sign',
+  RAW_SIGN = 'raw_sign',
+}
+
+class EnclaveSigner implements Signer {
+  private featureFlags: FeatureFlags
+  private keychain: KeychainAdapter
+  private enclaveMPCHost: string
+  private version = 'v6'
+  private portalApi?: HttpRequester
+  private requests: HttpRequester
+
+  constructor({
+    keychain,
+    enclaveMPCHost = 'mpc-client.portalhq.io',
+    version = 'v6',
+    portalApi,
+    featureFlags = {},
+  }: MpcSignerOptions & { enclaveMPCHost?: string }) {
+    this.featureFlags = featureFlags
+    this.keychain = keychain
+    this.enclaveMPCHost = enclaveMPCHost
+    this.version = version
+    this.portalApi = portalApi
+    this.requests = new HttpRequester({
+      baseUrl: `https://${this.enclaveMPCHost}`,
+    })
+  }
+
+  public async sign(
+    message: SigningRequestArguments,
+    provider: IPortalProvider,
+  ): Promise<any> {
+    // Always track metrics, but only send if feature flag is enabled
+    const shouldSendMetrics =
+      this.featureFlags.enableSdkPerformanceMetrics === true
+    const signStartTime = performance.now()
+    const preOperationStartTime = performance.now()
+
+    // Generate a traceId for this operation
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+    const traceId = (UUID as any).v4() as string
+    const metrics: Record<string, number | string | boolean> = {
+      hasError: false,
+      operation: Operation.SIGN,
+      signingMethod: message.method,
+      traceId,
+    }
+
+    try {
+      const eip155Address = await this.keychain.getEip155Address()
+      const apiKey = provider.apiKey
+      const { method, chainId, curve, isRaw } = message
+
+      // Add chainId to metrics
+      if (chainId) {
+        metrics.chainId = chainId
+      }
+
+      switch (method) {
+        case 'eth_requestAccounts':
+          return [eip155Address]
+        case 'eth_accounts':
+          return [eip155Address]
+        default:
+          break
+      }
+
+      const shares = await this.keychain.getShares()
+      let signingShare = shares.secp256k1.share
+
+      if (curve === PortalCurve.ED25519) {
+        if (!shares.ed25519) {
+          throw new Error(
+            '[Portal.Provider.EnclaveSigner] The ED25519 share is missing from the keychain.',
+          )
+        }
+        signingShare = shares.ed25519.share
+      }
+
+      const metadata: PortalMobileMpcMetadata = {
+        clientPlatform: 'REACT_NATIVE',
+        clientPlatformVersion: getClientPlatformVersion(),
+        isMultiBackupEnabled: this.featureFlags.isMultiBackupEnabled,
+        mpcServerVersion: this.version,
+        optimized: true,
+        curve,
+        chainId,
+        isRaw,
+        reqId: traceId,
+        connectionTracingEnabled: shouldSendMetrics,
+      }
+
+      let formattedParams: string
+      let rpcUrl: string
+
+      if (isRaw) {
+        formattedParams = JSON.stringify(
+          this.buildParams(method, message.params),
+        )
+        rpcUrl = ''
+        metrics.operation = Operation.RAW_SIGN
+      } else {
+        formattedParams = JSON.stringify(
+          this.buildParams(method, message.params),
+        )
+        rpcUrl = provider.getGatewayUrl(chainId)
+      }
+
+      if (typeof formattedParams !== 'string') {
+        throw new Error(
+          `[Portal.Provider.EnclaveSigner] The formatted params for the signing request could not be converted to a string. The params were: ${formattedParams}`,
+        )
+      }
+
+      // Record pre-operation time
+      metrics.sdkPreOperationMs = performance.now() - preOperationStartTime
+
+      // Measure enclave signing operation time
+      const enclaveSignStartTime = performance.now()
+
+      const result = isRaw
+        ? await this.enclaveRawSign(
+            apiKey,
+            JSON.stringify(signingShare),
+            formattedParams,
+            curve || 'SECP256K1',
+          )
+        : await this.enclaveSign(
+            apiKey,
+            JSON.stringify(signingShare),
+            message.method,
+            formattedParams,
+            rpcUrl,
+            chainId || '',
+            JSON.stringify(metadata),
+          )
+
+      // Post-operation processing time starts
+      const postOperationStartTime = performance.now()
+
+      // Record HTTP call time
+      metrics.enclaveHttpCallMs = performance.now() - enclaveSignStartTime
+
+      // Record post-operation time
+      metrics.sdkPostOperationMs = performance.now() - postOperationStartTime
+
+      // Calculate total SDK signing time
+      metrics.sdkOperationMs = performance.now() - signStartTime
+
+      // Log performance timing to console
+      const timingMetrics: Record<string, number> = {}
+      if (typeof metrics.sdkPreOperationMs === 'number') {
+        timingMetrics['Pre-operation'] = metrics.sdkPreOperationMs
+      }
+      if (typeof metrics.enclaveHttpCallMs === 'number') {
+        timingMetrics['Enclave HTTP Call'] = metrics.enclaveHttpCallMs
+      }
+      if (typeof metrics.sdkPostOperationMs === 'number') {
+        timingMetrics['Post-operation'] = metrics.sdkPostOperationMs
+      }
+
+      // Only send metrics if the feature flag is enabled
+      if (shouldSendMetrics && this.portalApi) {
+        try {
+          await this.sendMetrics(metrics, apiKey)
+        } catch (err) {
+          // No-op
+        }
+      }
+
+      return result
+    } catch (error) {
+      // Calculate total time even in error case
+      metrics.sdkOperationMs = performance.now() - signStartTime
+
+      // Log performance timing to console even in error case
+      const errorTimingMetrics: Record<string, number> = {}
+      if (typeof metrics.sdkPreOperationMs === 'number') {
+        errorTimingMetrics['Pre-operation'] = metrics.sdkPreOperationMs
+      }
+
+      // Only send metrics if the feature flag is enabled
+      if (shouldSendMetrics) {
+        const apiKey = provider.apiKey
+        metrics.hasError = true
+        try {
+          await this.sendMetrics(metrics, apiKey)
+        } catch {
+          // No-op
+        }
+      }
+
+      throw error
+    }
+  }
+
+  private async enclaveRawSign(
+    apiKey: string,
+    signingShare: string,
+    params: string,
+    curve: string,
+  ): Promise<string> {
+    if (!apiKey || !signingShare || !params || !curve) {
+      return this.encodeErrorResult(
+        'INVALID_PARAMETERS',
+        'Invalid parameters provided for raw signing',
+      )
+    }
+
+    const requestBody = {
+      params: params,
+      share: signingShare,
+    }
+
+    const endpoint = `/v1/raw/sign/${curve}`
+
+    try {
+      const response = await this.requests.post<EnclaveSignResponse>(endpoint, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: requestBody,
+      })
+
+      return this.encodeSuccessResult(response.data)
+    } catch (error: any) {
+      if (error?.response?.data) {
+        const portalError = this.decodePortalError(
+          JSON.stringify(error.response.data),
+        )
+        return this.encodeErrorResult(portalError?.id, portalError?.message)
+      }
+      return this.encodeErrorResult(
+        'SIGNING_NETWORK_ERROR',
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+        error.message || 'Network error occurred',
+      )
+    }
+  }
+
+  private async enclaveSign(
+    apiKey: string,
+    signingShare: string,
+    method: string,
+    params: string,
+    rpcURL: string,
+    chainId: string,
+    metadata: string,
+  ): Promise<string> {
+    if (
+      !apiKey ||
+      !signingShare ||
+      !method ||
+      !params ||
+      !chainId ||
+      !metadata
+    ) {
+      return this.encodeErrorResult(
+        'INVALID_PARAMETERS',
+        'Invalid parameters provided',
+      )
+    }
+
+    const requestBody: EnclaveSignRequest = {
+      method: method,
+      params: params,
+      share: signingShare,
+      chainId: chainId,
+      rpcUrl: rpcURL,
+      metadataStr: metadata,
+      clientPlatform: 'REACT_NATIVE',
+      clientPlatformVersion: getClientPlatformVersion(),
+    }
+
+    try {
+      const response = await this.requests.post<EnclaveSignResponse>(
+        '/v1/sign',
+        {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+          },
+          body: requestBody,
+        },
+      )
+
+      return this.encodeSuccessResult(response.data)
+    } catch (error: any) {
+      if (error?.response?.data) {
+        const portalError = this.decodePortalError(
+          JSON.stringify(error.response.data),
+        )
+        return this.encodeErrorResult(portalError?.id, portalError?.message)
+      }
+      return this.encodeErrorResult(
+        'SIGNING_NETWORK_ERROR',
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+        error.message || 'Network error occurred',
+      )
+    }
+  }
+
+  // Helper function to encode success results
+  private encodeSuccessResult(data: string): string {
+    const successResult: EnclaveSignResult = { data: data, error: undefined }
+    return this.encodeJSON(successResult)
+  }
+
+  // Helper function to decode Portal errors
+  private decodePortalError(
+    errorStr?: string,
+  ): { id?: string; message?: string } | null {
+    if (!errorStr) return null
+    try {
+      return JSON.parse(errorStr)
+    } catch {
+      return null
+    }
+  }
+
+  // Helper function to encode error results
+  private encodeErrorResult(id?: string, message?: string): string {
+    const errorResult: EnclaveSignResult = {
+      data: undefined,
+      error: { id, message },
+    }
+    return this.encodeJSON(errorResult)
+  }
+
+  // Helper function to encode any object to JSON string
+  private encodeJSON<T>(value: T): string {
+    try {
+      const jsonString = JSON.stringify(value)
+      return jsonString
+    } catch (error: any) {
+      return JSON.stringify({
+        error: {
+          id: 'ENCODING_ERROR',
+          message: `Failed to encode JSON: ${error.message}`,
+        },
+      })
+    }
+  }
+
+  private async sendMetrics(
+    metrics: Record<string, number | string | boolean>,
+    apiKey: string,
+  ): Promise<void> {
+    try {
+      if (this.portalApi) {
+        await this.portalApi.post('/api/v3/clients/me/sdk/metrics', {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+          },
+          body: metrics,
+        })
+      }
+    } catch {
+      // No-op
+    }
+  }
+
+  private buildParams = (method: string, txParams: any) => {
+    let params = txParams
+
+    switch (method) {
+      case 'eth_sign':
+      case 'personal_sign':
+      case 'eth_signTypedData_v3':
+      case 'eth_signTypedData_v4':
+      case 'sol_signMessage':
+      case 'sol_signTransaction':
+      case 'sol_signAndSendTransaction':
+      case 'sol_signAndConfirmTransaction':
+        if (!Array.isArray(txParams)) {
+          params = [txParams]
+        }
+        break
+      default:
+        if (Array.isArray(txParams)) {
+          if (txParams.length === 1) {
+            params = txParams[0]
+          }
+        }
+    }
+    return params
+  }
+}
+
+export default EnclaveSigner

package/src/signers/index.ts

@@ -1,2 +1,3 @@
 export { default as Signer } from './abstract'
 export { default as MpcSigner } from './mpc'
+export { default as EnclaveSigner } from './enclave'

package/src/signers/mpc.ts

@@ -189,7 +189,7 @@ class MpcSigner implements Signer {
         }
       }
 
-      if (error?.code > 0) {
+      if (error?.id) {
         throw new PortalMpcError(error)
       }
 

package/types.d.ts

@@ -25,6 +25,7 @@ export interface MpcSignerOptions extends SignerOptions {
   isSimulator?: boolean
   mpcHost?: string
   portalApi?: HttpRequester
+  enclaveMPCHost?: string
   version?: string
   featureFlags?: FeatureFlags
 }
@@ -86,6 +87,7 @@ export interface ProviderOptions {
   autoApprove?: boolean
   apiHost?: string
   mpcHost?: string
+  enclaveMPCHost?: string
   version?: string
   featureFlags?: FeatureFlags
 }
@@ -106,6 +108,30 @@ export interface SignResult {
   S: string
 }
 
+export interface EnclaveSignResult {
+  data?: string
+  error?: {
+    id?: string
+    message?: string
+  }
+}
+
+export interface ProviderOptions {
+  // Required
+  apiKey: string
+  keychain: KeychainAdapter
+  gatewayConfig: GatewayLike
+
+  // Optional
+  autoApprove?: boolean
+  apiHost?: string
+  mpcHost?: string
+  enclaveMPCHost?: string
+  version?: string
+  chainId?: string
+  featureFlags?: FeatureFlags
+}
+
 export interface SignerOptions {}
 
 export interface Eip1559 {
@@ -141,3 +167,22 @@ export interface SigningResponse {
 export interface SwitchEthereumChainParameter {
   chainId: number
 }
+
+export interface EnclaveSignRequest {
+  method: string
+  params: string
+  share: string
+  chainId: string
+  rpcUrl: string
+  metadataStr: string
+  clientPlatform: string
+  clientPlatformVersion: string
+}
+
+export interface EnclaveSignResponse {
+  data: string
+  error?: {
+    id: string
+    message: string
+  }
+}