@portal-hq/provider 4.1.3 → 4.1.5

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,323 @@
+"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,
+                };
+                // Build params
+                // Avoid double JSON encoding: if params is already a string (e.g. a hex message), pass it directly; otherwise stringify objects/arrays.
+                const params = this.buildParams(method, message.params);
+                let formattedParams;
+                if (isRaw) {
+                    if (typeof params !== 'string') {
+                        throw new Error('[Portal.Provider.EnclaveSigner] For raw signing, params must be a string (e.g., a hex-encoded message).');
+                    }
+                    formattedParams = params;
+                }
+                else {
+                    formattedParams =
+                        typeof params === 'string' ? params : JSON.stringify(params);
+                }
+                // Get RPC URL
+                const rpcUrl = isRaw ? '' : provider.getGatewayUrl(chainId);
+                // Set metrics operation
+                metrics.operation = isRaw ? Operation.RAW_SIGN : Operation.SIGN;
+                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