@portal-hq/provider 4.4.0 → 4.6.0

package/src/signers/enclave.ts

@@ -1,21 +1,23 @@
 import { PortalCurve } from '@portal-hq/core'
 import { FeatureFlags } from '@portal-hq/core/types'
 import {
+  DEFAULT_HOSTS,
   HttpRequester,
   IPortalProvider,
   KeychainAdapter,
   PortalErrorCodes,
   PortalMpcError,
   type SigningRequestArguments,
+  generateTraceId,
   getClientPlatformVersion,
-  DEFAULT_HOSTS,
+  sdkLogger,
 } from '@portal-hq/utils'
-import UUID from 'react-native-uuid'
 
 import {
+  type EnclaveSignResponse,
   type MpcSignerOptions,
   PortalMobileMpcMetadata,
-  type EnclaveSignResponse,
+  type PresignatureSource,
 } from '../../types'
 import Signer from './abstract'
 
@@ -31,6 +33,7 @@ class EnclaveSigner implements Signer {
   private version = 'v6'
   private portalApi?: HttpRequester
   private requests: HttpRequester
+  private presignatureSource?: PresignatureSource
 
   constructor({
     keychain,
@@ -38,12 +41,14 @@ class EnclaveSigner implements Signer {
     version = 'v6',
     portalApi,
     featureFlags = {},
+    presignatureSource,
   }: MpcSignerOptions & { enclaveMPCHost?: string }) {
     this.featureFlags = featureFlags
     this.keychain = keychain
     this.enclaveMPCHost = enclaveMPCHost ?? DEFAULT_HOSTS.ENCLAVE_MPC
     this.version = version
     this.portalApi = portalApi
+    this.presignatureSource = presignatureSource
     this.requests = new HttpRequester({
       baseUrl: `https://${this.enclaveMPCHost}`,
     })
@@ -59,9 +64,11 @@ class EnclaveSigner implements Signer {
     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
+    // Use traceId from message if available (e.g. options.traceId), otherwise generate a new UUID
+    const traceId = message.traceId ?? generateTraceId()
+    sdkLogger.info(
+      `[Portal MPC] enclave sign started | method=${message.method} | traceId=${traceId} | chainId=${message.chainId} | curve=${message.curve}`,
+    )
     const metrics: Record<string, number | string | boolean> = {
       hasError: false,
       operation: Operation.SIGN,
@@ -127,6 +134,34 @@ class EnclaveSigner implements Signer {
         connectionTracingEnabled: shouldSendMetrics,
       }
 
+      // Presignature path (SECP256K1 only): try consume before building params; fallback to normal sign.
+      if (
+        curve === PortalCurve.SECP256K1 &&
+        this.featureFlags.usePresignatures === true &&
+        this.presignatureSource
+      ) {
+        const presignature = await this.presignatureSource.consumePresignature(
+          PortalCurve.SECP256K1,
+        )
+        if (presignature?.data) {
+          sdkLogger.debug(
+            '[Portal] Signing with presignature (EnclaveSigner)',
+            { method: message.method, chainId: message.chainId },
+          )
+          try {
+            return await this.signWithPresignature(
+              { ...message, presignatureData: presignature.data, traceId },
+              provider,
+            )
+          } catch (presignError) {
+            sdkLogger.warn(
+              '[Portal.Provider.EnclaveSigner] signWithPresignature failed, falling back to normal sign:',
+              presignError,
+            )
+          }
+        }
+      }
+
       // 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)
@@ -172,6 +207,7 @@ class EnclaveSigner implements Signer {
         requestBody = {
           params: formattedParams,
           share: JSON.stringify(signingShare),
+          metadataStr: JSON.stringify(metadata),
         }
       } else {
         // Standard sign endpoint and body
@@ -195,6 +231,7 @@ class EnclaveSigner implements Signer {
           endpoint,
           apiKey,
           requestBody,
+          traceId,
         )
         result = this.processEnclaveResponse(response)
       } catch (error) {
@@ -310,6 +347,7 @@ class EnclaveSigner implements Signer {
     endpoint: string,
     apiKey: string,
     body: Record<string, any>,
+    traceId?: string,
   ): Promise<EnclaveSignResponse> {
     return await this.requests.post<EnclaveSignResponse>(endpoint, {
       headers: {
@@ -317,6 +355,7 @@ class EnclaveSigner implements Signer {
         'Content-Type': 'application/json',
       },
       body,
+      ...(traceId ? { traceId } : {}),
     })
   }
 
@@ -456,6 +495,165 @@ class EnclaveSigner implements Signer {
     }
     return params
   }
+
+  /**
+   * Sign using a pre-generated presignature via the Enclave REST API.
+   * Uses the same endpoints as normal signing (/v1/sign, /v1/raw/sign/:curve)
+   * but includes the optional `presignature` field in the request body.
+   * NOTE: Only supports SECP256K1 curve.
+   */
+  public async signWithPresignature(
+    message: SigningRequestArguments & { presignatureData: string },
+    provider: IPortalProvider,
+  ): Promise<string> {
+    const { method, chainId, isRaw = false, curve, presignatureData } = message
+
+    const targetCurve = curve || PortalCurve.SECP256K1
+    if (targetCurve !== PortalCurve.SECP256K1) {
+      throw new Error(
+        '[Portal.Provider.EnclaveSigner] Presignatures are only supported for SECP256K1 curve',
+      )
+    }
+
+    const shouldSendMetrics = this.featureFlags.enableSdkPerformanceMetrics
+    const traceId = message.traceId ?? generateTraceId()
+    const metrics: Record<string, number | string | boolean> = {
+      hasError: false,
+      operation: 'signWithPresignature',
+      signingMethod: method,
+      traceId,
+    }
+
+    if (chainId) {
+      metrics.chainId = chainId
+    }
+
+    const requestStartTime = performance.now()
+
+    try {
+      const preOperationStartTime = performance.now()
+
+      const apiKey = provider.apiKey
+      if (!apiKey) {
+        throw new Error(
+          '[Portal.Provider.EnclaveSigner] The API key is missing.',
+        )
+      }
+
+      const shares = await this.keychain.getShares()
+      const signingShare = shares.secp256k1.share
+
+      if (!signingShare) {
+        throw new Error(
+          '[Portal.Provider.EnclaveSigner] The SECP256K1 share is missing from the keychain.',
+        )
+      }
+
+      const metadata: PortalMobileMpcMetadata = {
+        clientPlatform: 'REACT_NATIVE',
+        clientPlatformVersion: getClientPlatformVersion(),
+        isMultiBackupEnabled: this.featureFlags.isMultiBackupEnabled,
+        mpcServerVersion: this.version,
+        optimized: true,
+        curve: PortalCurve.SECP256K1,
+        chainId,
+        isRaw,
+        reqId: traceId,
+        connectionTracingEnabled: shouldSendMetrics,
+      }
+
+      let endpoint: string
+      let requestBody: Record<string, any>
+
+      if (isRaw) {
+        const params = this.buildParams(method, message.params)
+        if (typeof params !== 'string') {
+          throw new Error(
+            '[Portal.Provider.EnclaveSigner] For raw signing with presignature, params must be a string (e.g., a hex-encoded message).',
+          )
+        }
+        endpoint = `/v1/raw/sign/${targetCurve}`
+        requestBody = {
+          params,
+          share: JSON.stringify(signingShare),
+          metadataStr: JSON.stringify(metadata),
+          presignature: presignatureData,
+        }
+        metrics.operation = 'raw_signWithPresignature'
+      } else {
+        const params = this.buildParams(method, message.params)
+        const formattedParams =
+          typeof params === 'string' ? params : JSON.stringify(params)
+        const rpcUrl = provider.getGatewayUrl(chainId)
+        endpoint = '/v1/sign'
+        requestBody = {
+          method: message.method,
+          params: formattedParams,
+          share: JSON.stringify(signingShare),
+          chainId: chainId || '',
+          rpcUrl,
+          metadataStr: JSON.stringify(metadata),
+          clientPlatform: 'REACT_NATIVE',
+          clientPlatformVersion: getClientPlatformVersion(),
+          presignature: presignatureData,
+        }
+      }
+
+      metrics.sdkPreOperationMs = performance.now() - preOperationStartTime
+
+      const enclaveSignStartTime = performance.now()
+
+      let result: string
+      try {
+        const response = await this.makeEnclaveRequest(
+          endpoint,
+          apiKey,
+          requestBody,
+          traceId,
+        )
+        result = this.processEnclaveResponse(response)
+      } catch (error) {
+        this.handleEnclaveError(error)
+      }
+
+      const postOperationStartTime = performance.now()
+
+      metrics.enclaveHttpCallMs = performance.now() - enclaveSignStartTime
+
+      metrics.sdkPostOperationMs = performance.now() - postOperationStartTime
+
+      metrics.sdkOperationMs = performance.now() - requestStartTime
+
+      if (shouldSendMetrics && this.portalApi) {
+        try {
+          await this.sendMetrics(metrics, apiKey)
+        } catch (error) {
+          // No-op
+        }
+      }
+
+      return result
+    } catch (error) {
+      sdkLogger.error(
+        '[Portal.Provider.EnclaveSigner] signWithPresignature error:',
+        error,
+      )
+
+      metrics.sdkOperationMs = performance.now() - requestStartTime
+      metrics.hasError = true
+
+      if (shouldSendMetrics && this.portalApi) {
+        const apiKey = provider.apiKey
+        try {
+          await this.sendMetrics(metrics, apiKey)
+        } catch (metricsError) {
+          // No-op
+        }
+      }
+
+      throw error
+    }
+  }
 }
 
 export default EnclaveSigner

package/src/signers/mpc.ts

@@ -1,21 +1,23 @@
 import { PortalCurve } from '@portal-hq/core'
 import { FeatureFlags } from '@portal-hq/core/types'
 import {
+  DEFAULT_HOSTS,
   HttpRequester,
   IPortalProvider,
   KeychainAdapter,
   PortalMpcError,
   type SigningRequestArguments,
+  generateTraceId,
   getClientPlatformVersion,
-  DEFAULT_HOSTS,
+  sdkLogger,
 } from '@portal-hq/utils'
 import { NativeModules } from 'react-native'
-import UUID from 'react-native-uuid'
 
 import {
   type MpcSignerOptions,
   type PortalMobileMpc,
   PortalMobileMpcMetadata,
+  type PresignatureSource,
   type SigningResponse,
 } from '../../types'
 import Signer from './abstract'
@@ -32,6 +34,7 @@ class MpcSigner implements Signer {
   private mpcHost: string
   private version = 'v6'
   private portalApi?: HttpRequester
+  private presignatureSource?: PresignatureSource
 
   constructor({
     keychain,
@@ -39,6 +42,7 @@ class MpcSigner implements Signer {
     version = 'v6',
     portalApi,
     featureFlags = {},
+    presignatureSource,
   }: MpcSignerOptions) {
     this.featureFlags = featureFlags
     this.keychain = keychain
@@ -46,6 +50,7 @@ class MpcSigner implements Signer {
     this.mpcHost = mpcHost
     this.version = version
     this.portalApi = portalApi
+    this.presignatureSource = presignatureSource
 
     if (!this.mpc) {
       throw new Error(
@@ -63,9 +68,11 @@ class MpcSigner implements Signer {
       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 as any).v4() as string
+    // Use traceId from message if available (e.g. options.traceId), otherwise generate a new UUID
+    const traceId = message.traceId ?? generateTraceId()
+    sdkLogger.info(
+      `[Portal MPC] sign started | method=${message.method} | traceId=${traceId} | chainId=${message.chainId} | curve=${message.curve}`,
+    )
     const metrics: Record<string, number | string | boolean> = {
       hasError: false,
       operation: Operation.SIGN,
@@ -149,6 +156,39 @@ class MpcSigner implements Signer {
         )
       }
 
+      // Internal presignature handling (gated by feature flag): when usePresignatures is true and a
+      // presignature is available for SECP256K1, use signWithPresignature; otherwise normal sign().
+      if (
+        curve === PortalCurve.SECP256K1 &&
+        this.featureFlags.usePresignatures === true &&
+        this.presignatureSource
+      ) {
+        const presignature = await this.presignatureSource.consumePresignature(
+          PortalCurve.SECP256K1,
+        )
+        if (presignature?.data) {
+          sdkLogger.debug(
+            '[Portal] Signing with presignature (portal.request/sendAsset path)',
+            { method: message.method, chainId: message.chainId },
+          )
+          try {
+            return await this.signWithPresignature(
+              {
+                ...message,
+                presignatureData: presignature.data,
+                traceId,
+              },
+              provider,
+            )
+          } catch (presignError) {
+            sdkLogger.warn(
+              '[Portal.Provider.MpcSigner] signWithPresignature failed, falling back to normal sign:',
+              presignError,
+            )
+          }
+        }
+      }
+
       // Record pre-operation time
       metrics.sdkPreOperationMs = performance.now() - preOperationStartTime
 
@@ -283,6 +323,188 @@ class MpcSigner implements Signer {
     }
     return params
   }
+
+  /**
+   * Sign a transaction using a pre-generated presignature
+   * NOTE: Only supports SECP256K1 curve
+   *
+   * @param message - Signing request with presignatureData
+   * @param provider - Portal provider instance
+   * @returns Signed transaction hash
+   */
+  public async signWithPresignature(
+    message: SigningRequestArguments & { presignatureData: string },
+    provider: IPortalProvider,
+  ): Promise<string> {
+    const {
+      method,
+      chainId,
+      isRaw = false,
+      curve,
+      sponsorGas,
+      signatureApprovalMemo,
+      presignatureData,
+    } = message
+
+    const targetCurve = curve || PortalCurve.SECP256K1
+    if (targetCurve !== PortalCurve.SECP256K1) {
+      throw new Error(
+        '[Portal.Provider.MpcSigner] Presignatures are only supported for SECP256K1 curve',
+      )
+    }
+
+    const shouldSendMetrics = this.featureFlags.enableSdkPerformanceMetrics
+    const traceId = message.traceId ?? generateTraceId()
+    const metrics: Record<string, number | string | boolean> = {
+      hasError: false,
+      operation: 'signWithPresignature',
+      signingMethod: method,
+      traceId,
+    }
+
+    if (chainId) {
+      metrics.chainId = chainId
+    }
+
+    const requestStartTime = performance.now()
+
+    try {
+      const preOperationStartTime = performance.now()
+
+      const apiKey = provider.apiKey
+      if (!apiKey) {
+        throw new Error('[Portal.Provider.MpcSigner] The API key is missing.')
+      }
+
+      const shares = await this.keychain.getShares()
+      const signingShare = shares.secp256k1.share
+
+      if (!signingShare) {
+        throw new Error(
+          '[Portal.Provider.MpcSigner] The SECP256K1 share is missing from the keychain.',
+        )
+      }
+
+      const metadata: PortalMobileMpcMetadata = {
+        clientPlatform: 'REACT_NATIVE',
+        clientPlatformVersion: getClientPlatformVersion(),
+        isMultiBackupEnabled: this.featureFlags.isMultiBackupEnabled,
+        mpcServerVersion: this.version,
+        optimized: true,
+        curve: PortalCurve.SECP256K1,
+        chainId,
+        isRaw,
+        reqId: traceId,
+        connectionTracingEnabled: shouldSendMetrics,
+        sponsorGas,
+        signatureApprovalMemo,
+      }
+
+      const stringifiedMetadata = JSON.stringify(metadata)
+
+      let formattedParams: string
+      let rpcUrl: string
+
+      if (isRaw) {
+        formattedParams = this.buildParams(method, message.params)
+        rpcUrl = ''
+        metrics.operation = 'raw_signWithPresignature'
+      } else {
+        formattedParams = JSON.stringify(
+          this.buildParams(method, message.params),
+        )
+        rpcUrl = provider.getGatewayUrl(chainId)
+      }
+
+      if (typeof formattedParams !== 'string') {
+        throw new Error(
+          `[Portal.Provider.MpcSigner] The formatted params for the signing request could not be converted to a string. The params were: ${formattedParams}`,
+        )
+      }
+
+      metrics.sdkPreOperationMs = performance.now() - preOperationStartTime
+
+      const mpcSignStartTime = performance.now()
+
+      const result = await this.mpc.signWithPresignature(
+        apiKey,
+        this.mpcHost,
+        JSON.stringify(signingShare),
+        presignatureData,
+        method,
+        formattedParams,
+        rpcUrl,
+        chainId,
+        stringifiedMetadata,
+      )
+
+      const postOperationStartTime = performance.now()
+
+      metrics.mpcNativeCallMs = performance.now() - mpcSignStartTime
+
+      const parsedResponse = JSON.parse(String(result)) as SigningResponse
+      const { data, error, meta } = parsedResponse
+
+      if (meta?.metrics) {
+        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 (binaryMetrics.firstResponseMs) {
+          metrics.sdkBinaryFirstResponseMs = binaryMetrics.firstResponseMs
+        }
+        if (binaryMetrics.dnsLookupMs) {
+          metrics.sdkBinaryDnsLookupMs = binaryMetrics.dnsLookupMs
+        }
+        if (binaryMetrics.connectMs) {
+          metrics.sdkBinaryConnectMs = binaryMetrics.connectMs
+        }
+      }
+
+      if (error?.id) {
+        throw new PortalMpcError(error)
+      }
+
+      metrics.sdkPostOperationMs = performance.now() - postOperationStartTime
+
+      metrics.sdkOperationMs = performance.now() - requestStartTime
+
+      if (shouldSendMetrics && this.portalApi) {
+        try {
+          await this.sendMetrics(metrics, apiKey)
+        } catch (error) {
+          // No-op
+        }
+      }
+
+      return data
+    } catch (error) {
+      sdkLogger.error(
+        '[Portal.Provider.MpcSigner] signWithPresignature error:',
+        error,
+      )
+
+      metrics.sdkOperationMs = performance.now() - requestStartTime
+      metrics.hasError = true
+
+      if (shouldSendMetrics && this.portalApi) {
+        const apiKey = provider.apiKey
+        try {
+          await this.sendMetrics(metrics, apiKey)
+        } catch (metricsError) {
+          // No-op
+        }
+      }
+
+      throw error
+    }
+  }
 }
 
 export default MpcSigner

package/types.d.ts

@@ -1,9 +1,10 @@
 // Types
 import PortalConnect from '@portal-hq/connect'
+import type { PortalCurve } from '@portal-hq/core'
 import {
+  HttpRequester,
   KeychainAdapter,
   type PortalError,
-  HttpRequester,
 } from '@portal-hq/utils'
 
 export type EventHandler = (data: any) => void
@@ -18,6 +19,11 @@ export interface GatewayConfig {
   [key: string]: string
 }
 
+/** Internal SDK only: used by MpcSigner to consume a presignature when signing (SECP256K1). Not exposed to consumers. */
+export interface PresignatureSource {
+  consumePresignature(curve: PortalCurve): Promise<{ data: string } | null>
+}
+
 export interface MpcSignerOptions extends SignerOptions {
   keychain: KeychainAdapter
 
@@ -28,6 +34,8 @@ export interface MpcSignerOptions extends SignerOptions {
   enclaveMPCHost?: string
   version?: string
   featureFlags?: FeatureFlags
+  /** Internal: presignature source for SECP256K1 signing (portal.request() uses this automatically). */
+  presignatureSource?: PresignatureSource
 }
 
 export interface PortalMobileMpcMetadata {
@@ -47,9 +55,11 @@ export interface PortalMobileMpcMetadata {
   optimized: true
   isRaw?: boolean
   reqId?: string
+  traceId?: string
   connectionTracingEnabled?: boolean
   sponsorGas?: boolean
   signatureApprovalMemo?: string
+  presignatureExpirationTs?: number
 }
 
 export interface PortalMobileMpc {
@@ -75,6 +85,17 @@ export interface PortalMobileMpc {
     chainId: string,
     metadata: string,
   ) => Promise<string>
+  signWithPresignature: (
+    clientApiKey: string,
+    mpcApiUrl: string,
+    dkgResult: string,
+    presignatureData: string,
+    method: string,
+    params: string,
+    rpcUrl: string,
+    chainId: string,
+    metadata: string,
+  ) => Promise<string>
 }
 
 export interface ProviderOptions {
@@ -92,6 +113,8 @@ export interface ProviderOptions {
   enclaveMPCHost?: string
   version?: string
   featureFlags?: FeatureFlags
+  /** Internal: presignature source for SECP256K1 signing (portal.request() uses this automatically). */
+  presignatureSource?: PresignatureSource
 }
 
 export interface RegisteredEventHandler {
@@ -132,6 +155,7 @@ export interface ProviderOptions {
   version?: string
   chainId?: string
   featureFlags?: FeatureFlags
+  presignatureSource?: PresignatureSource
 }
 
 export interface SignerOptions {}