@portal-hq/provider 4.4.0 → 4.6.0

package/lib/esm/signers/enclave.js

@@ -8,15 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { PortalCurve } from '@portal-hq/core';
-import { HttpRequester, PortalErrorCodes, PortalMpcError, getClientPlatformVersion, DEFAULT_HOSTS, } from '@portal-hq/utils';
-import UUID from 'react-native-uuid';
+import { DEFAULT_HOSTS, HttpRequester, PortalErrorCodes, PortalMpcError, generateTraceId, getClientPlatformVersion, sdkLogger, } from '@portal-hq/utils';
 var Operation;
 (function (Operation) {
     Operation["SIGN"] = "sign";
     Operation["RAW_SIGN"] = "raw_sign";
 })(Operation || (Operation = {}));
 class EnclaveSigner {
-    constructor({ keychain, enclaveMPCHost, version = 'v6', portalApi, featureFlags = {}, }) {
+    constructor({ keychain, enclaveMPCHost, version = 'v6', portalApi, featureFlags = {}, presignatureSource, }) {
         this.version = 'v6';
         this.buildParams = (method, txParams) => {
             let params = txParams;
@@ -47,19 +46,21 @@ class EnclaveSigner {
         this.enclaveMPCHost = enclaveMPCHost !== null && enclaveMPCHost !== void 0 ? enclaveMPCHost : DEFAULT_HOSTS.ENCLAVE_MPC;
         this.version = version;
         this.portalApi = portalApi;
+        this.presignatureSource = presignatureSource;
         this.requests = new HttpRequester({
             baseUrl: `https://${this.enclaveMPCHost}`,
         });
     }
     sign(message, provider) {
+        var _a;
         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();
+            // Use traceId from message if available (e.g. options.traceId), otherwise generate a new UUID
+            const traceId = (_a = message.traceId) !== null && _a !== void 0 ? _a : generateTraceId();
+            sdkLogger.info(`[Portal MPC] enclave sign started | method=${message.method} | traceId=${traceId} | chainId=${message.chainId} | curve=${message.curve}`);
             const metrics = {
                 hasError: false,
                 operation: Operation.SIGN,
@@ -114,6 +115,21 @@ class EnclaveSigner {
                     reqId: traceId,
                     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 = yield this.presignatureSource.consumePresignature(PortalCurve.SECP256K1);
+                    if (presignature === null || presignature === void 0 ? void 0 : presignature.data) {
+                        sdkLogger.debug('[Portal] Signing with presignature (EnclaveSigner)', { method: message.method, chainId: message.chainId });
+                        try {
+                            return yield this.signWithPresignature(Object.assign(Object.assign({}, 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);
@@ -148,6 +164,7 @@ class EnclaveSigner {
                     requestBody = {
                         params: formattedParams,
                         share: JSON.stringify(signingShare),
+                        metadataStr: JSON.stringify(metadata),
                     };
                 }
                 else {
@@ -167,7 +184,7 @@ class EnclaveSigner {
                 // Make API request and process response
                 let result;
                 try {
-                    const response = yield this.makeEnclaveRequest(endpoint, apiKey, requestBody);
+                    const response = yield this.makeEnclaveRequest(endpoint, apiKey, requestBody, traceId);
                     result = this.processEnclaveResponse(response);
                 }
                 catch (error) {
@@ -218,7 +235,7 @@ class EnclaveSigner {
                     try {
                         yield this.sendMetrics(metrics, apiKey);
                     }
-                    catch (_a) {
+                    catch (_b) {
                         // No-op
                     }
                 }
@@ -263,15 +280,12 @@ class EnclaveSigner {
      * Make HTTP request to Enclave API
      * Returns raw response without processing
      */
-    makeEnclaveRequest(endpoint, apiKey, body) {
+    makeEnclaveRequest(endpoint, apiKey, body, traceId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.requests.post(endpoint, {
-                headers: {
+            return yield this.requests.post(endpoint, Object.assign({ headers: {
                     Authorization: `Bearer ${apiKey}`,
                     'Content-Type': 'application/json',
-                },
-                body,
-            });
+                }, body }, (traceId ? { traceId } : {})));
         });
     }
     /**
@@ -369,5 +383,128 @@ class EnclaveSigner {
             }
         });
     }
+    /**
+     * 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.
+     */
+    signWithPresignature(message, provider) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = (_a = message.traceId) !== null && _a !== void 0 ? _a : generateTraceId();
+            const metrics = {
+                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 = yield 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 = {
+                    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;
+                let requestBody;
+                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;
+                try {
+                    const response = yield 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 {
+                        yield 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 {
+                        yield this.sendMetrics(metrics, apiKey);
+                    }
+                    catch (metricsError) {
+                        // No-op
+                    }
+                }
+                throw error;
+            }
+        });
+    }
 }
 export default EnclaveSigner;

package/lib/esm/signers/mpc.js

@@ -8,16 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { PortalCurve } from '@portal-hq/core';
-import { PortalMpcError, getClientPlatformVersion, DEFAULT_HOSTS, } from '@portal-hq/utils';
+import { DEFAULT_HOSTS, PortalMpcError, generateTraceId, getClientPlatformVersion, sdkLogger, } from '@portal-hq/utils';
 import { NativeModules } from 'react-native';
-import UUID from 'react-native-uuid';
 var Operation;
 (function (Operation) {
     Operation["SIGN"] = "sign";
     Operation["RAW_SIGN"] = "raw_sign";
 })(Operation || (Operation = {}));
 class MpcSigner {
-    constructor({ keychain, mpcHost = DEFAULT_HOSTS.MPC, version = 'v6', portalApi, featureFlags = {}, }) {
+    constructor({ keychain, mpcHost = DEFAULT_HOSTS.MPC, version = 'v6', portalApi, featureFlags = {}, presignatureSource, }) {
         this.version = 'v6';
         this.buildParams = (method, txParams) => {
             let params = txParams;
@@ -49,19 +48,21 @@ class MpcSigner {
         this.mpcHost = mpcHost;
         this.version = version;
         this.portalApi = portalApi;
+        this.presignatureSource = presignatureSource;
         if (!this.mpc) {
             throw new Error(`[Portal.Provider.MpcSigner] The MPC module could not be found by the signer. This is usually an issue with React Native linking. Please verify that the 'PortalReactNative' module is properly linked to this project.`);
         }
     }
     sign(message, provider) {
+        var _a;
         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-call
-            const traceId = UUID.v4();
+            // Use traceId from message if available (e.g. options.traceId), otherwise generate a new UUID
+            const traceId = (_a = message.traceId) !== null && _a !== void 0 ? _a : generateTraceId();
+            sdkLogger.info(`[Portal MPC] sign started | method=${message.method} | traceId=${traceId} | chainId=${message.chainId} | curve=${message.curve}`);
             const metrics = {
                 hasError: false,
                 operation: Operation.SIGN,
@@ -121,6 +122,22 @@ class MpcSigner {
                 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}`);
                 }
+                // 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 = yield this.presignatureSource.consumePresignature(PortalCurve.SECP256K1);
+                    if (presignature === null || presignature === void 0 ? void 0 : presignature.data) {
+                        sdkLogger.debug('[Portal] Signing with presignature (portal.request/sendAsset path)', { method: message.method, chainId: message.chainId });
+                        try {
+                            return yield this.signWithPresignature(Object.assign(Object.assign({}, 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;
                 // Measure MPC signing operation time
@@ -183,7 +200,7 @@ class MpcSigner {
                     try {
                         yield this.sendMetrics(metrics, apiKey);
                     }
-                    catch (_a) {
+                    catch (_b) {
                         // No-op
                     }
                 }
@@ -210,5 +227,133 @@ class MpcSigner {
             }
         });
     }
+    /**
+     * 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
+     */
+    signWithPresignature(message, provider) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = (_a = message.traceId) !== null && _a !== void 0 ? _a : generateTraceId();
+            const metrics = {
+                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 = yield 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 = {
+                    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;
+                let rpcUrl;
+                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 = yield 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));
+                const { data, error, meta } = parsedResponse;
+                if (meta === null || meta === void 0 ? void 0 : 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 === null || error === void 0 ? void 0 : error.id) {
+                    throw new PortalMpcError(error);
+                }
+                metrics.sdkPostOperationMs = performance.now() - postOperationStartTime;
+                metrics.sdkOperationMs = performance.now() - requestStartTime;
+                if (shouldSendMetrics && this.portalApi) {
+                    try {
+                        yield 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 {
+                        yield this.sendMetrics(metrics, apiKey);
+                    }
+                    catch (metricsError) {
+                        // No-op
+                    }
+                }
+                throw error;
+            }
+        });
+    }
 }
 export default MpcSigner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portal-hq/provider",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -19,8 +19,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@portal-hq/connect": "^4.4.0",
-    "@portal-hq/utils": "^4.4.0",
+    "@portal-hq/connect": "^4.6.0",
+    "@portal-hq/utils": "^4.6.0",
     "@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": "76ce311809d877d0f8aa5373b0f4e9d85ee963f0"
+  "gitHead": "81e3ade6164a87aa8fc8942af4c770d04f73bc55"
 }

package/src/providers/index.ts

@@ -1,6 +1,9 @@
 import PortalConnect from '@portal-hq/connect'
 import { PortalCurve } from '@portal-hq/core'
 import {
+  CHAIN_NAMESPACES,
+  DEFAULT_CHAIN_ID_CAIP2,
+  DEFAULT_HOSTS,
   Events,
   HttpRequester,
   IPortalProvider,
@@ -11,9 +14,7 @@ import {
   ProviderRpcError,
   type RequestArguments,
   RpcErrorCodes,
-  DEFAULT_CHAIN_ID_CAIP2,
-  CHAIN_NAMESPACES,
-  DEFAULT_HOSTS,
+  generateTraceId,
   sdkLogger,
 } from '@portal-hq/utils'
 import { AddressesByNamespace, RpcErrorOptions } from '@portal-hq/utils/types'
@@ -25,7 +26,8 @@ import {
   type RegisteredEventHandler,
   SwitchEthereumChainParameter,
 } from '../../types'
-import { MpcSigner, Signer, EnclaveSigner } from '../signers'
+import { EnclaveSigner, MpcSigner, Signer } from '../signers'
+
 const passiveSignerMethods = [
   'eth_accounts',
   'eth_chainId',
@@ -84,6 +86,7 @@ class Provider implements IPortalProvider {
     version = 'v6',
     chainId = DEFAULT_CHAIN_ID_CAIP2,
     featureFlags = {},
+    presignatureSource,
   }: ProviderOptions) {
     const finalApiHost = apiHost ?? DEFAULT_HOSTS.API
     const finalMpcHost = mpcHost ?? DEFAULT_HOSTS.MPC
@@ -128,6 +131,11 @@ class Provider implements IPortalProvider {
         version,
         portalApi: this.portalApi,
         featureFlags,
+        // Only pass presignatureSource when usePresignatures is enabled (same as MpcSigner).
+        presignatureSource:
+          featureFlags.usePresignatures === true
+            ? presignatureSource
+            : undefined,
       })
     } else {
       this.signer = new MpcSigner({
@@ -136,6 +144,11 @@ class Provider implements IPortalProvider {
         version,
         portalApi: this.portalApi,
         featureFlags,
+        // Only pass presignatureSource when usePresignatures is enabled; otherwise signer always uses normal sign().
+        presignatureSource:
+          featureFlags.usePresignatures === true
+            ? presignatureSource
+            : undefined,
       })
     }
   }
@@ -281,6 +294,7 @@ class Provider implements IPortalProvider {
     params,
     chainId,
     connect,
+    options,
   }: RequestArguments): Promise<any> {
     chainId = chainId ?? this.chainId
     if (!chainId) {
@@ -339,6 +353,7 @@ class Provider implements IPortalProvider {
         params,
         chainId,
         connect,
+        options,
       })
 
       if (transactionHash) {
@@ -545,6 +560,7 @@ class Provider implements IPortalProvider {
     params,
     chainId,
     connect,
+    options,
   }: RequestArguments): Promise<any> {
     const isApproved = passiveSignerMethods.includes(method)
       ? true
@@ -556,6 +572,7 @@ class Provider implements IPortalProvider {
       )
       return
     }
+    const traceId = options?.traceId ?? generateTraceId()
     let namespace: string = CHAIN_NAMESPACES.EIP155
     let reference: string | number | undefined = chainId
     if (typeof chainId == 'string' && chainId.includes(':')) {
@@ -591,6 +608,9 @@ class Provider implements IPortalProvider {
             params,
             curve,
             isRaw: false,
+            sponsorGas: options?.sponsorGas,
+            signatureApprovalMemo: options?.signatureApprovalMemo,
+            traceId,
           },
           this,
         )
@@ -600,11 +620,14 @@ class Provider implements IPortalProvider {
       case 'raw_sign': {
         const result = await this.signer?.sign(
           {
-            chainId: '',
-            method: '',
+            chainId: chainId ?? '',
+            method: 'raw_sign',
             params,
             curve,
             isRaw: true,
+            sponsorGas: options?.sponsorGas,
+            signatureApprovalMemo: options?.signatureApprovalMemo,
+            traceId,
           },
           this,
         )