@portal-hq/provider 4.1.2 → 4.1.4

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

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { PortalCurve } from '@portal-hq/core';
 import { PortalMpcError, getClientPlatformVersion, } from '@portal-hq/utils';
 import { NativeModules } from 'react-native';
+import UUID from 'react-native-uuid';
 var Operation;
 (function (Operation) {
     Operation["SIGN"] = "sign";
@@ -58,9 +59,14 @@ class MpcSigner {
             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-call
+            const traceId = UUID.v4();
             const metrics = {
-                operation: Operation.SIGN,
                 hasError: false,
+                operation: Operation.SIGN,
+                signingMethod: message.method,
+                traceId,
             };
             try {
                 const eip155Address = yield this.keychain.getEip155Address();
@@ -95,6 +101,8 @@ class MpcSigner {
                     curve,
                     chainId,
                     isRaw,
+                    reqId: traceId,
+                    connectionTracingEnabled: shouldSendMetrics,
                 };
                 const stringifiedMetadata = JSON.stringify(metadata);
                 let formattedParams;
@@ -125,14 +133,27 @@ class MpcSigner {
                 const { data, error, meta } = parsedResponse;
                 // Add binary metrics to our metrics object
                 if (meta === null || meta === void 0 ? void 0 : meta.metrics) {
-                    if (meta.metrics.wsConnectDurationMs) {
-                        metrics.sdkBinaryWSConnectMs = meta.metrics.wsConnectDurationMs;
+                    const binaryMetrics = meta.metrics;
+                    if (binaryMetrics.wsConnectDurationMs) {
+                        metrics.sdkBinaryWSConnectMs = binaryMetrics.wsConnectDurationMs;
+                    }
+                    if (binaryMetrics.operationDurationMs) {
+                        metrics.sdkBinaryOperationMs = binaryMetrics.operationDurationMs;
+                    }
+                    if (binaryMetrics.tlsHandshakeMs) {
+                        metrics.sdkBinaryTlsHandshakeMs = binaryMetrics.tlsHandshakeMs;
                     }
-                    if (meta.metrics.operationDurationMs) {
-                        metrics.sdkBinaryOperationMs = meta.metrics.operationDurationMs;
+                    if (binaryMetrics.firstResponseMs) {
+                        metrics.sdkBinaryFirstResponseMs = binaryMetrics.firstResponseMs;
+                    }
+                    if (binaryMetrics.dnsLookupMs) {
+                        metrics.sdkBinaryDnsLookupMs = binaryMetrics.dnsLookupMs;
+                    }
+                    if (binaryMetrics.connectMs) {
+                        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
@@ -144,7 +165,7 @@ class MpcSigner {
                     try {
                         yield this.sendMetrics(metrics, apiKey);
                     }
-                    catch (_a) {
+                    catch (err) {
                         // No-op
                     }
                 }
@@ -160,7 +181,7 @@ class MpcSigner {
                     try {
                         yield this.sendMetrics(metrics, apiKey);
                     }
-                    catch (_b) {
+                    catch (_a) {
                         // No-op
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portal-hq/provider",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -19,8 +19,10 @@
     "test": "jest"
   },
   "dependencies": {
-    "@portal-hq/connect": "^4.1.2",
-    "@portal-hq/utils": "^4.1.2"
+    "@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"
   },
   "devDependencies": {
     "@babel/preset-typescript": "^7.18.6",
@@ -30,5 +32,5 @@
     "ts-jest": "^29.0.3",
     "typescript": "^4.8.4"
   },
-  "gitHead": "4504ed5bdfde36df2b9c1acab9916ad412ba6fd9"
+  "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