@portal-hq/web 3.9.0 → 3.10.0-alpha.2

package/lib/commonjs/__mocks__/delegations.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockTransferFromResponse = exports.mockTransferFromRequest = exports.mockGetStatusResponse = exports.mockGetStatusRequest = exports.mockEVMRevokeResponse = exports.mockEVMRevokeRequest = exports.mockEVMApproveResponse = exports.mockEVMApproveRequest = exports.mockHost = void 0;
+exports.mockHost = 'web.portalhq.io';
+exports.mockEVMApproveRequest = {
+    chain: 'eip155:1',
+    token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    delegateAddress: '0x1234567890123456789012345678901234567890',
+    amount: '1000000000',
+};
+exports.mockEVMApproveResponse = {
+    transactions: [
+        {
+            from: '0xUserAddress',
+            to: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+            data: '0x095ea7b3',
+            value: '0x0',
+        },
+    ],
+    metadata: {
+        chainId: 'eip155:1',
+        delegateAmount: '1000',
+        delegateAmountRaw: '1000000000',
+        delegateAddress: '0x1234567890123456789012345678901234567890',
+        tokenSymbol: 'USDC',
+        tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        ownerAddress: '0xUserAddress',
+    },
+};
+exports.mockEVMRevokeRequest = {
+    chain: 'eip155:1',
+    token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    delegateAddress: '0x1234567890123456789012345678901234567890',
+};
+exports.mockEVMRevokeResponse = {
+    transactions: [
+        {
+            from: '0xUserAddress',
+            to: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+            data: '0x095ea7b3',
+            value: '0x0',
+        },
+    ],
+    metadata: {
+        chainId: 'eip155:1',
+        revokedAddress: '0x1234567890123456789012345678901234567890',
+        tokenSymbol: 'USDC',
+        tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        ownerAddress: '0xUserAddress',
+    },
+};
+exports.mockGetStatusRequest = {
+    chain: 'eip155:1',
+    token: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    delegateAddress: '0x1234567890123456789012345678901234567890',
+};
+exports.mockGetStatusResponse = {
+    chainId: 'eip155:1',
+    token: 'USDC',
+    tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    balance: '5000',
+    balanceRaw: '5000000000',
+    delegations: [
+        {
+            address: '0x1234567890123456789012345678901234567890',
+            delegateAmount: '1000',
+            delegateAmountRaw: '1000000000',
+        },
+    ],
+};
+exports.mockTransferFromRequest = {
+    chain: 'eip155:11155111',
+    token: 'USDC',
+    fromAddress: '0xc53fbaea2daa07f2a3d7e586aeed7b3b92fe2985',
+    toAddress: '0xdFd8302f44727A6348F702fF7B594f127dE3A902',
+    amount: '1.0',
+};
+exports.mockTransferFromResponse = {
+    transactions: [
+        {
+            from: exports.mockTransferFromRequest.fromAddress,
+            to: exports.mockTransferFromRequest.toAddress,
+            data: '0xmockdata',
+            value: '0x1',
+        },
+    ],
+    metadata: {
+        chainId: 'eip155:11155111',
+        amount: exports.mockTransferFromRequest.amount,
+        amountRaw: '1000000',
+        tokenSymbol: 'USDC',
+    },
+};

package/lib/commonjs/index.js

@@ -42,7 +42,9 @@ const provider_1 = __importStar(require("./provider"));
 const yield_1 = __importDefault(require("./integrations/yield"));
 const trading_1 = __importDefault(require("./integrations/trading"));
 const security_1 = __importDefault(require("./integrations/security"));
+const delegations_1 = __importDefault(require("./integrations/delegations"));
 const passkeys_1 = __importDefault(require("./passkeys"));
+const evmAccountType_1 = require("./namespaces/evmAccountType");
 class Portal {
     get ready() {
         return this.mpc.ready;
@@ -88,10 +90,12 @@ class Portal {
         this.yield = new yield_1.default({ mpc: this.mpc });
         this.trading = new trading_1.default({ mpc: this.mpc });
         this.security = new security_1.default({ mpc: this.mpc });
+        this.delegations = new delegations_1.default({ mpc: this.mpc });
         this.provider = new provider_1.default({
             portal: this,
             chainId: chainId ? Number(chainId) : undefined,
         });
+        this.evmAccountType = new evmAccountType_1.EvmAccountType({ mpc: this.mpc });
     }
     /*****************************
      * Initialization Methods
@@ -156,14 +160,16 @@ class Portal {
     }) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.mpc.backup({
-                backupMethod: BackupMethods.custom,
-                backupConfigs: {},
+                backupMethod: BackupMethods.passkey,
+                backupConfigs: {
+                    skipStorageWrite: true,
+                },
                 host: this.host,
                 mpcVersion: this.mpcVersion,
                 featureFlags: this.featureFlags,
             }, progress);
             if (!response.encryptionKey) {
-                throw new Error('[Portal] Custom backup did not return an encryption key. Please ensure you are using the latest iframe bundle.');
+                throw new Error('[Portal] Passkey backup did not return an encryption key. Please ensure you are using the latest iframe bundle.');
             }
             return {
                 cipherText: response.cipherText,

package/lib/commonjs/index.test.js

@@ -145,7 +145,7 @@ describe('Portal', () => {
         }));
     });
     describe('generateBackupShare', () => {
-        it('should request a custom backup and return cipherText and encryptionKey', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should request a passkey backup with skipStorageWrite and return cipherText and encryptionKey', () => __awaiter(void 0, void 0, void 0, function* () {
             const storageCallback = jest.fn().mockResolvedValue(undefined);
             portal.mpc.backup.mockResolvedValueOnce({
                 cipherText: constants_1.mockCipherText,
@@ -158,8 +158,10 @@ describe('Portal', () => {
                 encryptionKey: 'manual-key',
             });
             expect(portal.mpc.backup).toHaveBeenCalledWith({
-                backupMethod: _1.BackupMethods.custom,
-                backupConfigs: {},
+                backupMethod: _1.BackupMethods.passkey,
+                backupConfigs: {
+                    skipStorageWrite: true,
+                },
                 host: 'web.portalhq.io',
                 mpcVersion: 'v6',
                 featureFlags: {},
@@ -171,7 +173,7 @@ describe('Portal', () => {
                 cipherText: constants_1.mockCipherText,
                 storageCallback: jest.fn(),
             });
-            yield expect(portal.generateBackupShare()).rejects.toThrow('Custom backup did not return an encryption key');
+            yield expect(portal.generateBackupShare()).rejects.toThrow('Passkey backup did not return an encryption key');
         }));
     });
     describe('registerPasskeyAndStoreEncryptionKey', () => {

package/lib/commonjs/integrations/delegations/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class Delegations {
+    constructor({ mpc }) {
+        this.mpc = mpc;
+    }
+    /**
+     * Approves a delegation for a specified token on a given chain.
+     * Returns transactions for EVM chains or encodedTransactions for Solana chains.
+     * @param params - Delegation approval parameters
+     * @returns Promise resolving to approval response with transaction data
+     */
+    approve(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.delegationsApprove(params);
+        });
+    }
+    /**
+     * Revokes a delegation for a specified token on a given chain.
+     * Returns transactions for EVM chains or encodedTransactions for Solana chains.
+     * @param params - Delegation revocation parameters
+     * @returns Promise resolving to revocation response with transaction data
+     */
+    revoke(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.delegationsRevoke(params);
+        });
+    }
+    /**
+     * Retrieves the delegation status for a specified token and delegate address.
+     * @param params - Delegation status query parameters
+     * @returns Promise resolving to delegation status information
+     */
+    getStatus(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.delegationsGetStatus(params);
+        });
+    }
+    /**
+     * Transfers tokens from one address to another using delegated authority.
+     * The caller must have been previously approved as a delegate.
+     * Returns transactions for EVM chains or encodedTransactions for Solana chains.
+     * @param params - Transfer from delegation parameters
+     * @returns Promise resolving to transfer response with transaction data
+     */
+    transferFrom(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.delegationsTransferFrom(params);
+        });
+    }
+}
+exports.default = Delegations;

package/lib/commonjs/integrations/delegations/index.test.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = __importDefault(require("."));
+const mpc_1 = __importDefault(require("../../mpc"));
+const portal_1 = __importDefault(require("../../__mocks/portal/portal"));
+const delegations_1 = require("../../__mocks__/delegations");
+describe('Delegations', () => {
+    let delegations;
+    let mpc;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portal_1.default.host = delegations_1.mockHost;
+        mpc = new mpc_1.default({
+            portal: portal_1.default,
+        });
+        delegations = new _1.default({ mpc });
+    });
+    describe('approve', () => {
+        it('should call mpc.delegationsApprove with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'delegationsApprove')
+                .mockResolvedValue(delegations_1.mockEVMApproveResponse);
+            const result = yield delegations.approve(delegations_1.mockEVMApproveRequest);
+            expect(spy).toHaveBeenCalledWith(delegations_1.mockEVMApproveRequest);
+            expect(result).toEqual(delegations_1.mockEVMApproveResponse);
+        }));
+        it('should propagate errors from mpc.delegationsApprove', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'delegationsApprove').mockRejectedValue(error);
+            yield expect(delegations.approve(delegations_1.mockEVMApproveRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('revoke', () => {
+        it('should call mpc.delegationsRevoke with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'delegationsRevoke')
+                .mockResolvedValue(delegations_1.mockEVMRevokeResponse);
+            const result = yield delegations.revoke(delegations_1.mockEVMRevokeRequest);
+            expect(spy).toHaveBeenCalledWith(delegations_1.mockEVMRevokeRequest);
+            expect(result).toEqual(delegations_1.mockEVMRevokeResponse);
+        }));
+        it('should propagate errors from mpc.delegationsRevoke', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'delegationsRevoke').mockRejectedValue(error);
+            yield expect(delegations.revoke(delegations_1.mockEVMRevokeRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('getStatus', () => {
+        it('should call mpc.delegationsGetStatus with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'delegationsGetStatus')
+                .mockResolvedValue(delegations_1.mockGetStatusResponse);
+            const result = yield delegations.getStatus(delegations_1.mockGetStatusRequest);
+            expect(spy).toHaveBeenCalledWith(delegations_1.mockGetStatusRequest);
+            expect(result).toEqual(delegations_1.mockGetStatusResponse);
+        }));
+        it('should propagate errors from mpc.delegationsGetStatus', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'delegationsGetStatus').mockRejectedValue(error);
+            yield expect(delegations.getStatus(delegations_1.mockGetStatusRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('transferFrom', () => {
+        it('should call mpc.delegationsTransferFrom with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'delegationsTransferFrom')
+                .mockResolvedValue(delegations_1.mockTransferFromResponse);
+            const result = yield delegations.transferFrom(delegations_1.mockTransferFromRequest);
+            expect(spy).toHaveBeenCalledWith(delegations_1.mockTransferFromRequest);
+            expect(result).toEqual(delegations_1.mockTransferFromResponse);
+        }));
+        it('should propagate errors from mpc.delegationsTransferFrom', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'delegationsTransferFrom').mockRejectedValue(error);
+            yield expect(delegations.transferFrom(delegations_1.mockTransferFromRequest)).rejects.toThrow('Test error');
+        }));
+    });
+});

package/lib/commonjs/mpc/index.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MpcErrorCodes = exports.MpcError = void 0;
 const errors_1 = require("./errors");
 const index_1 = require("../index");
-const WEB_SDK_VERSION = '3.9.0';
+const WEB_SDK_VERSION = '3.10.0-alpha.2';
 class Mpc {
     get ready() {
         return this._ready;
@@ -650,11 +650,65 @@ class Mpc {
             });
         });
     }
+    /*******************************
+     * Delegations Methods
+     *******************************/
+    delegationsApprove(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:delegations:approve',
+                errorMessage: 'portal:delegations:approveError',
+                resultMessage: 'portal:delegations:approveResult',
+                data,
+            });
+        });
+    }
+    delegationsRevoke(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:delegations:revoke',
+                errorMessage: 'portal:delegations:revokeError',
+                resultMessage: 'portal:delegations:revokeResult',
+                data,
+            });
+        });
+    }
+    delegationsGetStatus(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:delegations:getStatus',
+                errorMessage: 'portal:delegations:getStatusError',
+                resultMessage: 'portal:delegations:getStatusResult',
+                data,
+            });
+        });
+    }
+    delegationsTransferFrom(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:delegations:transferFrom',
+                errorMessage: 'portal:delegations:transferFromError',
+                resultMessage: 'portal:delegations:transferFromResult',
+                data,
+            });
+        });
+    }
     /***************************
      * Private Methods
      ***************************/
     /**
-     * Util to handle requests to the iframe and post the result to the parent
+     * Util to handle requests to the iframe and post the result to the parent.
+     *
+     * @remarks
+     * This is an advanced/internal API intended primarily for low-level integrations
+     * (for example, framework or account-type abstractions such as EvmAccountType).
+     * Typical consumers should prefer using the higher-level methods exposed on
+     * the {@link Mpc} class (e.g. {@link delegationsApprove}, {@link delegationsRevoke},
+     * {@link delegationsGetStatus}, {@link delegationsTransferFrom}) instead of calling
+     * this method directly.
+     *
+     * This method is not part of the stable public surface area and may change in
+     * future releases without notice.
      */
     handleRequestToIframeAndPost({ methodMessage, errorMessage, resultMessage, data, progressMessage, progressCallback, mapReturnValue, }) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/commonjs/namespaces/evmAccountType/index.js

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmAccountType = void 0;
+const index_1 = require("../../index");
+class EvmAccountType {
+    constructor({ mpc }) {
+        this.mpc = mpc;
+    }
+    /**
+     * Get the account type for a given chain
+     * @param {EvmAccountTypeGetStatusRequest} params - The request parameters
+     * @returns {Promise<EvmAccountTypeGetStatusResponse>} The account type
+     */
+    getStatus({ chain, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.handleRequestToIframeAndPost({
+                methodMessage: 'portal:evmAccountType:getStatus',
+                errorMessage: 'portal:evmAccountType:getStatusError',
+                resultMessage: 'portal:evmAccountType:getStatusResult',
+                data: { chain },
+            });
+        });
+    }
+    /**
+     * Build the authorization list for a given chain.
+     * @param {BuildAuthorizationListRequest} params - The request parameters
+     * @returns {Promise<BuildAuthorizationListResponse>} The authorization list
+     */
+    buildAuthorizationList(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.handleRequestToIframeAndPost({
+                methodMessage: 'portal:evmAccountType:buildAuthorizationList',
+                errorMessage: 'portal:evmAccountType:buildAuthorizationListError',
+                resultMessage: 'portal:evmAccountType:buildAuthorizationListResult',
+                data: params,
+            });
+        });
+    }
+    /**
+     * Build the 7702 upgrade transaction for a given chain.
+     * @param {Build7702UpgradeTxRequest} params - The request parameters
+     * @returns {Promise<Build7702UpgradeTxResponse>} The upgrade transaction
+     */
+    build7702UpgradeTx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.handleRequestToIframeAndPost({
+                methodMessage: 'portal:evmAccountType:build7702UpgradeTx',
+                errorMessage: 'portal:evmAccountType:build7702UpgradeTxError',
+                resultMessage: 'portal:evmAccountType:build7702UpgradeTxResult',
+                data: params,
+            });
+        });
+    }
+    /**
+     * Upgrade the account to EIP-7702. This handles the entire upgrade process, including building the authorization list, signing the transaction, and sending the transaction.
+     * @param {UpgradeTo7702Request} params - The request parameters
+     * @returns {Promise<UpgradeTo7702Response>} The upgrade response
+     */
+    upgradeTo7702(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { chain } = params;
+            if (!chain.startsWith('eip155:')) {
+                throw new Error(`Invalid chain for EIP-7702 upgrade. Expected EVM chain (eip155:*), got: ${chain}`);
+            }
+            const accountType = yield this.getStatus({ chain });
+            if (accountType.data.status === 'SMART_CONTRACT') {
+                throw new Error('Account is already a smart contract. EIP-7702 upgrade is only available for EOA accounts.');
+            }
+            if (accountType.data.status === 'EIP_7702_EOA') {
+                throw new Error('Account is already upgraded to EIP-7702.');
+            }
+            if (accountType.data.status !== 'EIP_155_EOA') {
+                throw new Error(`Unexpected account type: ${accountType.data.status}`);
+            }
+            const authorizationList = yield this.buildAuthorizationList({
+                chain,
+                subsidize: true,
+            });
+            const hashWithoutPrefix = authorizationList.data.hash.startsWith('0x')
+                ? authorizationList.data.hash.slice(2)
+                : authorizationList.data.hash;
+            const rawSignTx = yield this.mpc.rawSign(index_1.PortalCurve.SECP256K1, hashWithoutPrefix);
+            const upgradeTx = yield this.build7702UpgradeTx({
+                chain,
+                signature: rawSignTx,
+                subsidize: true,
+            });
+            const txHash = upgradeTx.data.transactionHash;
+            if (!txHash) {
+                throw new Error('Transaction hash not returned from build7702UpgradeTx. The upgrade transaction may not have been submitted.');
+            }
+            return { txHash };
+        });
+    }
+}
+exports.EvmAccountType = EvmAccountType;