@portal-hq/web 3.16.0 → 3.17.0-alpha.0

package/lib/esm/index.test.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import Portal, { BackupMethods, GetTransactionsOrder } from '.';
-import { mockAddress, mockBackupConfig, mockBlockHashResponse, mockBuiltTronTransaction, mockCipherText, mockClientResponse, mockEip155Address, mockEjectResult, mockEjectPrivateKeysResult, mockEthRpcUrl, mockEthTransaction, mockMpcBackupResponse, mockOrgBackupShare, mockOrgBackupShares, mockQuoteArgs, mockRpcConfig, mockSharesOnDevice, mockSignedHash, mockSolanaAddress, mockSolRpcUrl, mockTronAddress, } from './__mocks/constants';
+import Portal, { BackupMethods, GetTransactionsOrder, PortalCurve } from '.';
+import { mockAddress, mockBackupConfig, mockBlockHashResponse, mockBuiltEip155Transaction, mockBuiltEip155TransactionNative, mockBuiltTronTransaction, mockBuildBatchedUserOpRequest, mockBuildBatchedUserOpResponse, mockBroadcastBatchedUserOpRequest, mockBroadcastBatchedUserOpResponse, mockCipherText, mockClientResponse, mockEip155Address, mockEjectResult, mockEjectPrivateKeysResult, mockEthRpcUrl, mockEthTransaction, mockMpcBackupResponse, mockOrgBackupShare, mockOrgBackupShares, mockQuoteArgs, mockRpcConfig, mockSendBatchUserOpRequest, mockSharesOnDevice, mockSignedHash, mockSolanaAddress, mockSolRpcUrl, mockTronAddress, } from './__mocks/constants';
 import mpcMock from './__mocks/portal/mpc';
 import providerMock from './__mocks/portal/provider';
 /**
@@ -719,6 +719,237 @@ describe('Portal', () => {
             expect(portal.mpc.getSources).toHaveBeenCalledWith('eip155:1', 'test');
         }));
     });
+    describe('buildBatchedUserOp', () => {
+        it('should correctly call mpc.accountAbstractionBuildBatchedUserOp', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.buildBatchedUserOp(mockBuildBatchedUserOpRequest);
+            expect(portal.mpc.accountAbstractionBuildBatchedUserOp).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.accountAbstractionBuildBatchedUserOp).toHaveBeenCalledWith(mockBuildBatchedUserOpRequest);
+        }));
+    });
+    describe('broadcastBatchedUserOp', () => {
+        it('should correctly call mpc.accountAbstractionBroadcastBatchedUserOp', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.broadcastBatchedUserOp(mockBroadcastBatchedUserOpRequest);
+            expect(portal.mpc.accountAbstractionBroadcastBatchedUserOp).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.accountAbstractionBroadcastBatchedUserOp).toHaveBeenCalledWith(mockBroadcastBatchedUserOpRequest);
+        }));
+    });
+    describe('sendBatchUserOp', () => {
+        it('should build, sign, and broadcast a batched UserOperation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield portal.sendBatchUserOp(mockSendBatchUserOpRequest);
+            expect(result).toEqual(expect.objectContaining({
+                data: expect.objectContaining({ userOpHash: expect.any(String) }),
+                metadata: expect.objectContaining({ chainId: expect.any(String) }),
+            }));
+            // buildTransaction called once per transaction descriptor
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledTimes(2);
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(mockSendBatchUserOpRequest.chain, mockSendBatchUserOpRequest.transactions[0].to, mockSendBatchUserOpRequest.transactions[0].token, mockSendBatchUserOpRequest.transactions[0].value, expect.any(String));
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(mockSendBatchUserOpRequest.chain, mockSendBatchUserOpRequest.transactions[1].to, mockSendBatchUserOpRequest.transactions[1].token, mockSendBatchUserOpRequest.transactions[1].value, expect.any(String));
+            // buildBatchedUserOp called with ERC-20 call shape (no value field) and the shared traceId
+            expect(portal.mpc.accountAbstractionBuildBatchedUserOp).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.accountAbstractionBuildBatchedUserOp).toHaveBeenCalledWith({
+                chain: mockSendBatchUserOpRequest.chain,
+                calls: [
+                    {
+                        to: mockBuiltEip155Transaction.transaction.to,
+                        data: mockBuiltEip155Transaction.transaction.data,
+                    },
+                    {
+                        to: mockBuiltEip155Transaction.transaction.to,
+                        data: mockBuiltEip155Transaction.transaction.data,
+                    },
+                ],
+            }, expect.any(String));
+            // rawSign called with SECP256K1 and the userOpHash with 0x prefix stripped
+            expect(portal.mpc.rawSign).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.rawSign).toHaveBeenCalledWith(PortalCurve.SECP256K1, mockBuildBatchedUserOpResponse.data.userOpHash.slice(2), { signatureApprovalMemo: undefined, traceId: expect.any(String) });
+            // broadcastBatchedUserOp called with the built userOperation and signature, and the shared traceId
+            expect(portal.mpc.accountAbstractionBroadcastBatchedUserOp).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.accountAbstractionBroadcastBatchedUserOp).toHaveBeenCalledWith({
+                chain: mockSendBatchUserOpRequest.chain,
+                userOperation: mockBuildBatchedUserOpResponse.data.userOperation,
+                signature: mockSignedHash,
+            }, expect.any(String));
+        }));
+        it('should propagate the same traceId to buildBatchedUserOp and broadcastBatchedUserOp', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.sendBatchUserOp(mockSendBatchUserOpRequest);
+            const buildTraceId = portal.mpc.accountAbstractionBuildBatchedUserOp.mock.calls[0][1];
+            const broadcastTraceId = portal.mpc.accountAbstractionBroadcastBatchedUserOp.mock.calls[0][1];
+            expect(typeof buildTraceId).toBe('string');
+            expect(buildTraceId).toEqual(broadcastTraceId);
+        }));
+        it('should include value in the call for native ETH transfers', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockResolvedValueOnce(mockBuiltEip155TransactionNative);
+            yield portal.sendBatchUserOp({
+                chain: 'eip155:1',
+                transactions: [{ token: 'ETH', value: '0.1', to: '0x1111111111111111111111111111111111111111' }],
+            });
+            expect(portal.mpc.accountAbstractionBuildBatchedUserOp).toHaveBeenCalledWith({
+                chain: 'eip155:1',
+                calls: [
+                    {
+                        to: mockBuiltEip155TransactionNative.transaction.to,
+                        data: '0x',
+                        value: mockBuiltEip155TransactionNative.metadata.rawAmount,
+                    },
+                ],
+            }, expect.any(String));
+        }));
+        it('should not include value in the call for ERC-20 transfers', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.sendBatchUserOp({
+                chain: 'eip155:1',
+                transactions: [{ token: 'USDC', value: '1.0', to: '0x1111111111111111111111111111111111111111' }],
+            });
+            const calls = portal.mpc.accountAbstractionBuildBatchedUserOp.mock.calls[0][0].calls;
+            expect(calls[0]).not.toHaveProperty('value');
+        }));
+        it('should forward signatureApprovalMemo to rawSign', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield portal.sendBatchUserOp(Object.assign(Object.assign({}, mockSendBatchUserOpRequest), { signatureApprovalMemo: 'approve this batch' }));
+            expect(portal.mpc.rawSign).toHaveBeenCalledWith(PortalCurve.SECP256K1, expect.any(String), { signatureApprovalMemo: 'approve this batch', traceId: expect.any(String) });
+        }));
+        it('should throw if chain is not eip155', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendBatchUserOp(Object.assign(Object.assign({}, mockSendBatchUserOpRequest), { chain: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp' }))).rejects.toThrow('[Portal.sendBatchUserOp] UserOperations are only supported on EIP-155 (EVM) chains');
+        }));
+        it('should throw if transactions array is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendBatchUserOp(Object.assign(Object.assign({}, mockSendBatchUserOpRequest), { transactions: [] }))).rejects.toThrow('[Portal.sendBatchUserOp] transactions must contain at least one transaction');
+        }));
+        it('should throw with index context if buildTransaction fails for transaction 0', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockRejectedValueOnce(new Error('Network error'));
+            yield expect(portal.sendBatchUserOp({
+                chain: 'eip155:1',
+                transactions: [{ token: 'USDC', value: '1.0', to: '0x1111111111111111111111111111111111111111' }],
+            })).rejects.toThrow('[Portal.sendBatchUserOp] Failed to build call for transaction at index 0: Network error');
+        }));
+        it('should throw with index context if buildTransaction fails for transaction 1', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction
+                .mockResolvedValueOnce(mockBuiltEip155Transaction)
+                .mockRejectedValueOnce(new Error('Network error'));
+            yield expect(portal.sendBatchUserOp(mockSendBatchUserOpRequest)).rejects.toThrow('[Portal.sendBatchUserOp] Failed to build call for transaction at index 1: Network error');
+        }));
+        it('should throw if buildBatchedUserOp fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.accountAbstractionBuildBatchedUserOp.mockRejectedValueOnce(new Error('UserOp build failed'));
+            yield expect(portal.sendBatchUserOp(mockSendBatchUserOpRequest)).rejects.toThrow('[Portal.sendBatchUserOp] Failed to build UserOperation: UserOp build failed');
+        }));
+        it('should throw if rawSign fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.rawSign.mockRejectedValueOnce(new Error('Signing failed'));
+            yield expect(portal.sendBatchUserOp(mockSendBatchUserOpRequest)).rejects.toThrow('[Portal.sendBatchUserOp] Failed to sign userOpHash: Signing failed');
+        }));
+        it('should throw if broadcastBatchedUserOp fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.accountAbstractionBroadcastBatchedUserOp.mockRejectedValueOnce(new Error('Broadcast failed'));
+            yield expect(portal.sendBatchUserOp(mockSendBatchUserOpRequest)).rejects.toThrow('[Portal.sendBatchUserOp] Failed to broadcast UserOperation: Broadcast failed');
+        }));
+    });
+    describe('sendBatchedAssets', () => {
+        const feeRecipient = '0x2222222222222222222222222222222222222222';
+        const baseRequest = {
+            chain: 'eip155:1',
+            transactions: [
+                {
+                    token: 'USDC',
+                    value: '1.0',
+                    to: '0x1111111111111111111111111111111111111111',
+                },
+            ],
+        };
+        it('should build twice, convert gas to a fee, sign, and broadcast', () => __awaiter(void 0, void 0, void 0, function* () {
+            const convertGasToFeeAmount = jest.fn().mockResolvedValue('0.5');
+            const result = yield portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount } }));
+            expect(result).toEqual(mockBroadcastBatchedUserOpResponse);
+            // Estimation pass + final pass = 2 builds.
+            expect(portal.mpc.accountAbstractionBuildBatchedUserOp).toHaveBeenCalledTimes(2);
+            // buildTransaction: 1 user tx + 1 placeholder fee + 1 real fee = 3.
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledTimes(3);
+            // Conversion called once with gasCostWei = totalGas(100000) * maxFeePerGas(1e9).
+            expect(convertGasToFeeAmount).toHaveBeenCalledTimes(1);
+            expect(convertGasToFeeAmount).toHaveBeenCalledWith(BigInt('100000000000000'));
+            // Placeholder fee call built with the default '0.01'; real fee call with '0.5'.
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith('eip155:1', feeRecipient, 'USDC', '0.01', expect.any(String));
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith('eip155:1', feeRecipient, 'USDC', '0.5', expect.any(String));
+            expect(portal.mpc.rawSign).toHaveBeenCalledTimes(1);
+            expect(portal.mpc.accountAbstractionBroadcastBatchedUserOp).toHaveBeenCalledTimes(1);
+        }));
+        it('should apply bufferBps to the gas cost before conversion', () => __awaiter(void 0, void 0, void 0, function* () {
+            const convertGasToFeeAmount = jest.fn().mockResolvedValue('0.6');
+            yield portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: {
+                    feeToken: 'USDC',
+                    feeRecipient,
+                    convertGasToFeeAmount,
+                    bufferBps: 1000, // +10%
+                } }));
+            // 1e14 * 11000 / 10000 = 1.1e14
+            expect(convertGasToFeeAmount).toHaveBeenCalledWith(BigInt('110000000000000'));
+        }));
+        it('should throw if the build response is missing estimatedGasCostWei', () => __awaiter(void 0, void 0, void 0, function* () {
+            const noGasCost = Object.assign(Object.assign({}, mockBuildBatchedUserOpResponse), { metadata: { chainId: 'eip155:1' } });
+            portal.mpc.accountAbstractionBuildBatchedUserOp.mockResolvedValueOnce(noGasCost);
+            const convertGasToFeeAmount = jest.fn();
+            yield expect(portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount } }))).rejects.toThrow('[Portal.sendBatchedAssets] build response is missing metadata.estimatedGasCostWei');
+            // Conversion should never run if we can't determine the gas cost.
+            expect(convertGasToFeeAmount).not.toHaveBeenCalled();
+        }));
+        it('should throw if the estimated gas cost is 0 (e.g. Ultra Relay zero-fee path)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const zeroCost = Object.assign(Object.assign({}, mockBuildBatchedUserOpResponse), { metadata: {
+                    chainId: 'eip155:1',
+                    totalGas: '2000000',
+                    maxFeePerGas: '0',
+                    estimatedGasCostWei: '0',
+                } });
+            portal.mpc.accountAbstractionBuildBatchedUserOp.mockResolvedValueOnce(zeroCost);
+            const convertGasToFeeAmount = jest.fn();
+            yield expect(portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount } }))).rejects.toThrow('[Portal.sendBatchedAssets] Estimated gas cost is 0');
+            expect(convertGasToFeeAmount).not.toHaveBeenCalled();
+        }));
+        it('should reuse the same traceId across both builds', () => __awaiter(void 0, void 0, void 0, function* () {
+            const convertGasToFeeAmount = jest.fn().mockResolvedValue('0.5');
+            yield portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount } }));
+            const calls = portal.mpc.accountAbstractionBuildBatchedUserOp.mock.calls;
+            expect(typeof calls[0][1]).toBe('string');
+            expect(calls[0][1]).toEqual(calls[1][1]);
+        }));
+        it('should throw if chain is not eip155', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendBatchedAssets({
+                chain: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+                transactions: baseRequest.transactions,
+                gasReimbursement: {
+                    feeToken: 'USDC',
+                    feeRecipient,
+                    convertGasToFeeAmount: () => '1',
+                },
+            })).rejects.toThrow('[Portal.sendBatchedAssets] UserOperations are only supported on EIP-155 (EVM) chains');
+        }));
+        it('should throw if transactions is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendBatchedAssets({
+                chain: 'eip155:1',
+                transactions: [],
+                gasReimbursement: {
+                    feeToken: 'USDC',
+                    feeRecipient,
+                    convertGasToFeeAmount: () => '1',
+                },
+            })).rejects.toThrow('[Portal.sendBatchedAssets] transactions must contain at least one transaction');
+        }));
+        it('should throw if convertGasToFeeAmount is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: { feeToken: 'USDC', feeRecipient } }))).rejects.toThrow('[Portal.sendBatchedAssets] gasReimbursement.convertGasToFeeAmount (a function) is required');
+        }));
+        it('should throw if feeRecipient is not a valid EVM address', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: {
+                    feeToken: 'USDC',
+                    feeRecipient: '0xnope',
+                    convertGasToFeeAmount: () => '1',
+                } }))).rejects.toThrow('[Portal.sendBatchedAssets] Invalid gasReimbursement.feeRecipient');
+        }));
+        it('should surface an error thrown by the conversion callback', () => __awaiter(void 0, void 0, void 0, function* () {
+            const convertGasToFeeAmount = jest
+                .fn()
+                .mockRejectedValue(new Error('rate unavailable'));
+            yield expect(portal.sendBatchedAssets(Object.assign(Object.assign({}, baseRequest), { gasReimbursement: { feeToken: 'USDC', feeRecipient, convertGasToFeeAmount } }))).rejects.toThrow('[Portal.sendBatchedAssets] gasReimbursement.convertGasToFeeAmount threw: rate unavailable');
+        }));
+    });
     describe('storedClientBackupShare', () => {
         it('should correctly call mpc.storedClientBackupShare', () => __awaiter(void 0, void 0, void 0, function* () {
             yield portal.storedClientBackupShare(true, BackupMethods.password);

package/lib/esm/mpc/index.js

@@ -11,7 +11,7 @@ import { PortalMpcError } from './errors';
 import { sdkLogger } from '../logger';
 import { BackupMethods, } from '../index';
 import { generateTraceId } from '../shared/trace';
-const WEB_SDK_VERSION = '3.16.0';
+const WEB_SDK_VERSION = '3.17.0-alpha.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -226,6 +226,7 @@ class Mpc {
                     param }, ((options === null || options === void 0 ? void 0 : options.signatureApprovalMemo) !== undefined && {
                     signatureApprovalMemo: options.signatureApprovalMemo,
                 })),
+                traceId: options === null || options === void 0 ? void 0 : options.traceId,
             });
         });
     }
@@ -913,6 +914,31 @@ class Mpc {
             });
         });
     }
+    /*******************************
+     * Account Abstraction Methods
+     *******************************/
+    accountAbstractionBuildBatchedUserOp(data, traceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:accountAbstraction:buildBatchedUserOp',
+                errorMessage: 'portal:accountAbstraction:buildBatchedUserOpError',
+                resultMessage: 'portal:accountAbstraction:buildBatchedUserOpResult',
+                data,
+                traceId,
+            });
+        });
+    }
+    accountAbstractionBroadcastBatchedUserOp(data, traceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:accountAbstraction:broadcastBatchedUserOp',
+                errorMessage: 'portal:accountAbstraction:broadcastBatchedUserOpError',
+                resultMessage: 'portal:accountAbstraction:broadcastBatchedUserOpResult',
+                data,
+                traceId,
+            });
+        });
+    }
     /***************************
      * Private Methods
      ***************************/

package/lib/esm/mpc/index.test.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { BackupMethods, MpcStatuses, PortalCurve } from '../index';
 import Mpc from '.';
-import { mockAddress, mockApikey, mockAssets, mockBackupConfig, mockBackupIds, mockBalances, mockBuiltTransaction, mockCipherText, mockClientResponse, mockEjectResult, mockEjectPrivateKeysResult, mockEvaluationResult, mockHost, mockNFTs, mockOrgBackupShares, mockQuoteArgs, mockRpcUrl, mockSharesOnDevice, mockSimulationResult, mockTransactionToEvaluate, mockTransactionToSimulate, mockYieldXyzGetYieldsRequest, mockYieldXyzGetYieldsResponse, mockYieldXyzEnterRequest, mockYieldXyzEnterResponse, mockYieldXyzExitRequest, mockYieldXyzExitResponse, mockYieldXyzGetBalancesRequest, mockYieldXyzGetBalancesResponse, mockYieldXyzGetHistoricalActionsRequest, mockYieldXyzGetHistoricalActionsResponse, mockYieldXyzManageYieldRequest, mockYieldXyzManageYieldResponse, mockYieldXyzTrackTransactionRequest, mockYieldXyzTrackTransactionResponse, mockYieldXyzGetTransactionResponse, mockLifiGetRoutesRequest, mockLifiGetRoutesResponse, mockLifiGetQuoteRequest, mockLifiGetQuoteResponse, mockLifiGetStatusRequest, mockLifiGetStatusResponse, mockLifiGetRouteStepRequest, mockLifiGetRouteStepResponse, mockZeroExQuoteV2Request, mockZeroExQuoteV2Response, mockZeroExSourcesV2Request, mockZeroExSourcesV2Response, mockZeroExPriceRequest, mockZeroExPriceResponse, mockZeroExOptions, mockScanAddressesRequest, mockScanAddressesResponse, mockScanEVMTxRequest, mockScanEVMTxResponse, mockScanEip712TxRequest, mockScanEip712TxResponse, mockScanSolanaTxRequest, mockScanSolanaTxResponse, mockScanNftRequest, mockScanNftResponse, mockScanTokenRequest, mockScanTokenResponse, mockScanUrlRequest, mockScanUrlResponse, mockBlockaidScanEvmTxRequest, mockBlockaidScanEvmTxResponse, mockBlockaidScanSolanaTxRequest, mockBlockaidScanSolanaTxResponse, mockBlockaidScanAddressRequest, mockBlockaidScanAddressResponse, mockBlockaidScanTokensRequest, mockBlockaidScanTokensResponse, mockBlockaidScanUrlRequest, mockBlockaidScanUrlResponse, } from '../__mocks/constants';
+import { mockAddress, mockApikey, mockAssets, mockBackupConfig, mockBackupIds, mockBalances, mockBuiltTransaction, mockCipherText, mockClientResponse, mockEjectResult, mockEjectPrivateKeysResult, mockEvaluationResult, mockHost, mockNFTs, mockOrgBackupShares, mockQuoteArgs, mockRpcUrl, mockSharesOnDevice, mockSimulationResult, mockTransactionToEvaluate, mockTransactionToSimulate, mockYieldXyzGetYieldsRequest, mockYieldXyzGetYieldsResponse, mockYieldXyzEnterRequest, mockYieldXyzEnterResponse, mockYieldXyzExitRequest, mockYieldXyzExitResponse, mockYieldXyzGetBalancesRequest, mockYieldXyzGetBalancesResponse, mockYieldXyzGetHistoricalActionsRequest, mockYieldXyzGetHistoricalActionsResponse, mockYieldXyzManageYieldRequest, mockYieldXyzManageYieldResponse, mockYieldXyzTrackTransactionRequest, mockYieldXyzTrackTransactionResponse, mockYieldXyzGetTransactionResponse, mockLifiGetRoutesRequest, mockLifiGetRoutesResponse, mockLifiGetQuoteRequest, mockLifiGetQuoteResponse, mockLifiGetStatusRequest, mockLifiGetStatusResponse, mockLifiGetRouteStepRequest, mockLifiGetRouteStepResponse, mockZeroExQuoteV2Request, mockZeroExQuoteV2Response, mockZeroExSourcesV2Request, mockZeroExSourcesV2Response, mockZeroExPriceRequest, mockZeroExPriceResponse, mockZeroExOptions, mockScanAddressesRequest, mockScanAddressesResponse, mockScanEVMTxRequest, mockScanEVMTxResponse, mockScanEip712TxRequest, mockScanEip712TxResponse, mockScanSolanaTxRequest, mockScanSolanaTxResponse, mockScanNftRequest, mockScanNftResponse, mockScanTokenRequest, mockScanTokenResponse, mockScanUrlRequest, mockScanUrlResponse, mockBlockaidScanEvmTxRequest, mockBlockaidScanEvmTxResponse, mockBlockaidScanSolanaTxRequest, mockBlockaidScanSolanaTxResponse, mockBlockaidScanAddressRequest, mockBlockaidScanAddressResponse, mockBlockaidScanTokensRequest, mockBlockaidScanTokensResponse, mockBlockaidScanUrlRequest, mockBlockaidScanUrlResponse, mockBuildBatchedUserOpRequest, mockBuildBatchedUserOpResponse, mockBroadcastBatchedUserOpRequest, mockBroadcastBatchedUserOpResponse, } from '../__mocks/constants';
 import portalMock from '../__mocks/portal/portal';
 import { PortalMpcError } from './errors';
 describe('Mpc', () => {
@@ -3759,4 +3759,138 @@ describe('Mpc', () => {
             });
         });
     });
+    describe('accountAbstractionBuildBatchedUserOp', () => {
+        const args = mockBuildBatchedUserOpRequest;
+        const res = mockBuildBatchedUserOpResponse;
+        it('should successfully build a user operation', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:accountAbstraction:buildBatchedUserOp');
+                expect(data).toMatchObject(args);
+                expect(typeof message.traceId).toBe('string');
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:accountAbstraction:buildBatchedUserOpResult',
+                        data: res,
+                    },
+                }));
+            });
+            mpc
+                .accountAbstractionBuildBatchedUserOp(args)
+                .then((data) => {
+                expect(data).toEqual(res);
+                done();
+            })
+                .catch((_) => {
+                expect(0).toEqual(1);
+                done();
+            });
+        });
+        it('should error out if the iframe sends an error message', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:accountAbstraction:buildBatchedUserOp');
+                expect(data).toMatchObject(args);
+                expect(typeof message.traceId).toBe('string');
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:accountAbstraction:buildBatchedUserOpError',
+                        data: {
+                            code: 1,
+                            message: 'test',
+                        },
+                    },
+                }));
+            });
+            mpc
+                .accountAbstractionBuildBatchedUserOp(args)
+                .then(() => {
+                expect(0).toEqual(1);
+                done();
+            })
+                .catch((e) => {
+                expect(e).toBeInstanceOf(PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('accountAbstractionBroadcastBatchedUserOp', () => {
+        const args = mockBroadcastBatchedUserOpRequest;
+        const res = mockBroadcastBatchedUserOpResponse;
+        it('should successfully broadcast a user operation', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:accountAbstraction:broadcastBatchedUserOp');
+                expect(data).toMatchObject(args);
+                expect(typeof message.traceId).toBe('string');
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:accountAbstraction:broadcastBatchedUserOpResult',
+                        data: res,
+                    },
+                }));
+            });
+            mpc
+                .accountAbstractionBroadcastBatchedUserOp(args)
+                .then((data) => {
+                expect(data).toEqual(res);
+                done();
+            })
+                .catch((_) => {
+                expect(0).toEqual(1);
+                done();
+            });
+        });
+        it('should error out if the iframe sends an error message', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, origin) => {
+                const { type, data } = message;
+                expect(type).toEqual('portal:accountAbstraction:broadcastBatchedUserOp');
+                expect(data).toMatchObject(args);
+                expect(typeof message.traceId).toBe('string');
+                expect(origin).toEqual(mockHostOrigin);
+                window.dispatchEvent(new MessageEvent('message', {
+                    origin: mockHostOrigin,
+                    data: {
+                        type: 'portal:accountAbstraction:broadcastBatchedUserOpError',
+                        data: {
+                            code: 1,
+                            message: 'test',
+                        },
+                    },
+                }));
+            });
+            mpc
+                .accountAbstractionBroadcastBatchedUserOp(args)
+                .then(() => {
+                expect(0).toEqual(1);
+                done();
+            })
+                .catch((e) => {
+                expect(e).toBeInstanceOf(PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
 });

package/lib/esm/shared/types/accountAbstraction.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/shared/types/index.js

@@ -16,3 +16,5 @@ export * from './lifi';
 export * from './noah';
 export * from './hypernative';
 export * from './blockaid';
+// Account Abstraction types
+export * from './accountAbstraction';

package/package.json

@@ -3,7 +3,7 @@
   "description": "Portal MPC Support for Web",
   "author": "Portal Labs, Inc.",
   "homepage": "https://portalhq.io/",
-  "version": "3.16.0",
+  "version": "3.17.0-alpha.0",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -58,5 +58,6 @@
   },
   "dependencies": {
     "@solana/web3.js": "^1.91.8"
-  }
+  },
+  "stableVersion": "3.16.0-alpha.1"
 }

package/src/__mocks/constants.ts

@@ -13,9 +13,15 @@ import {
   Build7702UpgradeTxResponse,
   BuildAuthorizationListRequest,
   BuildAuthorizationListResponse,
+  BuildBatchedUserOpRequest,
+  BuildBatchedUserOpResponse,
+  BroadcastBatchedUserOpRequest,
+  BroadcastBatchedUserOpResponse,
+  BuiltEip155Transaction,
   EvmAccountTypeGetStatusRequest,
   EvmAccountTypeGetStatusResponse,
   GetAddressesResponse,
+  SendBatchUserOpRequest,
   UpgradeTo7702Request,
   UpgradeTo7702Response,
 } from 'src/shared/types'
@@ -2085,3 +2091,90 @@ export const mockUpgradeTo7702Request = {
 export const mockUpgradeTo7702Response = {
   txHash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
 } as UpgradeTo7702Response
+
+export const mockBuildBatchedUserOpRequest = {
+  chain: 'eip155:1',
+  calls: [
+    {
+      to: '0xcae0d97d201ad54275b6e8a6b547c7611ad47963',
+      value: '0',
+      data: '0x',
+    },
+  ],
+} as BuildBatchedUserOpRequest
+
+export const mockBuildBatchedUserOpResponse = {
+  data: {
+    userOperation:
+      '{"sender":"0xabc","nonce":"0x0","initCode":"0x","callData":"0x","callGasLimit":"0x5208","verificationGasLimit":"0x0186A0","preVerificationGas":"0xC350","maxFeePerGas":"0x3B9ACA00","maxPriorityFeePerGas":"0x3B9ACA00","paymasterAndData":"0x","signature":"0x"}',
+    userOpHash:
+      '0xdeadbeef1234567890abcdef1234567890abcdef1234567890abcdef12345678',
+  },
+  metadata: {
+    chainId: 'eip155:1',
+    // Gas info as decimal strings (matching connect-api): totalGas (units),
+    // maxFeePerGas (wei/gas), estimatedGasCostWei = totalGas * maxFeePerGas.
+    totalGas: '100000',
+    maxFeePerGas: '1000000000',
+    estimatedGasCostWei: '100000000000000',
+  },
+} as BuildBatchedUserOpResponse
+
+export const mockBroadcastBatchedUserOpRequest = {
+  chain: 'eip155:1',
+  userOperation:
+    '{"sender":"0xabc","nonce":"0x0","initCode":"0x","callData":"0x","callGasLimit":"0x5208","verificationGasLimit":"0x0186A0","preVerificationGas":"0xC350","maxFeePerGas":"0x3B9ACA00","maxPriorityFeePerGas":"0x3B9ACA00","paymasterAndData":"0x","signature":"0x1234"}',
+  signature: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab',
+} as BroadcastBatchedUserOpRequest
+
+export const mockBroadcastBatchedUserOpResponse = {
+  data: {
+    userOpHash:
+      '0xfeedface1234567890abcdef1234567890abcdef1234567890abcdef12345678',
+  },
+  metadata: {
+    chainId: 'eip155:1',
+  },
+} as BroadcastBatchedUserOpResponse
+
+// ERC-20 token transfer (data contains calldata, no native ETH value)
+export const mockBuiltEip155Transaction = {
+  transaction: {
+    from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    to: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+    data: '0xa9059cbb000000000000000000000000111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000f4240',
+  },
+  metadata: {
+    amount: '1.0',
+    fromAddress: '0xsender',
+    toAddress: '0xrecipient',
+    tokenAddress: '0xusdc-contract',
+    tokenDecimals: 6,
+    rawAmount: '1000000',
+  },
+} as BuiltEip155Transaction
+
+// Native ETH transfer (data is "0x", value comes from rawAmount)
+export const mockBuiltEip155TransactionNative = {
+  transaction: {
+    from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    to: '0x1111111111111111111111111111111111111111',
+    data: '0x',
+  },
+  metadata: {
+    amount: '0.1',
+    fromAddress: '0xsender',
+    toAddress: '0xrecipient',
+    tokenAddress: '0x0000000000000000000000000000000000000000',
+    tokenDecimals: 18,
+    rawAmount: '100000000000000000',
+  },
+} as BuiltEip155Transaction
+
+export const mockSendBatchUserOpRequest = {
+  chain: 'eip155:1',
+  transactions: [
+    { token: 'USDC', value: '1.0', to: '0x1111111111111111111111111111111111111111' },
+    { token: 'USDC', value: '2.0', to: '0x2222222222222222222222222222222222222222' },
+  ],
+} as SendBatchUserOpRequest

package/src/__mocks/portal/mpc.ts

@@ -1,5 +1,8 @@
 import {
   mockAddress,
+  mockBuiltEip155Transaction,
+  mockBuildBatchedUserOpResponse,
+  mockBroadcastBatchedUserOpResponse,
   mockClientResponse,
   mockEjectResult,
   mockEjectPrivateKeysResult,
@@ -28,5 +31,13 @@ mpcMock.ejectPrivateKeys = jest
   .mockResolvedValue(mockEjectPrivateKeysResult)
 mpcMock.checkSharesOnDevice = jest.fn().mockResolvedValue(mockSharesOnDevice)
 mpcMock.setBackupStatus = jest.fn().mockResolvedValue(true)
+mpcMock.rawSign = jest.fn().mockResolvedValue(mockSignedHash)
+mpcMock.buildTransaction = jest.fn().mockResolvedValue(mockBuiltEip155Transaction)
+mpcMock.accountAbstractionBuildBatchedUserOp = jest
+  .fn()
+  .mockResolvedValue(mockBuildBatchedUserOpResponse)
+mpcMock.accountAbstractionBroadcastBatchedUserOp = jest
+  .fn()
+  .mockResolvedValue(mockBroadcastBatchedUserOpResponse)
 
 export default mpcMock as jest.Mocked<Mpc>