@portal-hq/web 0.0.1-beta-1

package/lib/esm/index.js

@@ -0,0 +1,196 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Mpc from './mpc';
+import Provider from './provider';
+import DefaultBackupStorage from './storage';
+class Portal {
+    constructor({ 
+    // Required
+    apiKey, gatewayConfig, 
+    // Optional
+    apiHost = 'api.portalhq.io', autoApprove = false, backup = { default: new DefaultBackupStorage() }, chainId = 1, mpcHost = 'mpc.portalhq.io', mpcVersion = 'v4', webHost = 'web.portalhq.io', }) {
+        this.ready = false;
+        this.readyCallbacks = [];
+        this.apiHost = apiHost;
+        this.apiKey = apiKey;
+        this.autoApprove = autoApprove;
+        this.backup = backup;
+        this.chainId = chainId;
+        this.gatewayConfig = gatewayConfig;
+        this.mpcHost = mpcHost;
+        this.mpcVersion = mpcVersion;
+        this.rpcUrl = this.getRpcUrl();
+        this.webHost = webHost;
+        console.log(`Backup:`, this.backup);
+        // Portal Instances
+        this.mpc = new Mpc({
+            apiHost: this.apiHost,
+            apiKey: this.apiKey,
+            autoApprove: this.autoApprove,
+            chainId: this.chainId,
+            mpcHost: this.mpcHost,
+            rpcUrl: this.rpcUrl,
+            webHost: this.webHost,
+            portal: this,
+        });
+        this.provider = new Provider({
+            autoApprove: this.autoApprove,
+            mpcHost: this.mpcHost,
+            mpcVersion: this.mpcVersion,
+            portal: this,
+        });
+    }
+    /*****************************
+     * Initialization Methods
+     *****************************/
+    onReady(callback) {
+        if (this.ready) {
+            callback();
+        }
+        else {
+            this.readyCallbacks.push(callback);
+        }
+    }
+    triggerReady() {
+        if (this.ready && this.readyCallbacks.length > 0) {
+            this.readyCallbacks.forEach((callback) => {
+                callback();
+            });
+            this.readyCallbacks = [];
+        }
+    }
+    /*****************************
+     * Wallet Methods
+     *****************************/
+    createWallet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.mpc.generate({
+                host: this.mpcHost,
+                mpcVersion: this.mpcVersion,
+            });
+            this.address = address;
+            return address;
+        });
+    }
+    backupWallet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mpc.backup({
+                host: this.mpcHost,
+                mpcVersion: this.mpcVersion,
+            });
+            return '';
+        });
+    }
+    recoverWallet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mpc.recover({
+                host: this.mpcHost,
+                mpcVersion: this.mpcVersion,
+            });
+            return true;
+        });
+    }
+    /****************************
+     * Provider Methods
+     ****************************/
+    ethSendTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.request({
+                method: 'eth_sendTransaction',
+                params: transaction,
+            });
+        });
+    }
+    ethSign(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.request({
+                method: 'eth_sign',
+                params: [this.address, this.stringToHex(message)],
+            });
+        });
+    }
+    ethSignTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.request({
+                method: 'eth_signTransaction',
+                params: transaction,
+            });
+        });
+    }
+    ethSignTypedData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.request({
+                method: 'eth_signTypedData',
+                params: [this.address, data],
+            });
+        });
+    }
+    ethSignTypedDataV3(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.request({
+                method: 'eth_signTypedData_v3',
+                params: [this.address, data],
+            });
+        });
+    }
+    ethSignTypedDataV4(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.request({
+                method: 'eth_signTypedData_v4',
+                params: [this.address, data],
+            });
+        });
+    }
+    personalSign(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.request({
+                method: 'personal_sign',
+                params: [this.stringToHex(message), this.address],
+            });
+        });
+    }
+    /****************************
+     * RPC Methods
+     ****************************/
+    getRpcUrl() {
+        if (typeof this.gatewayConfig === 'string') {
+            // If the gatewayConfig is just a static URL, return that
+            return this.gatewayConfig;
+        }
+        else if (typeof this.gatewayConfig === 'object' &&
+            !this.gatewayConfig.hasOwnProperty(this.chainId)) {
+            // If there's no explicit mapping for the current chainId, error out
+            throw new Error(`[PortalProvider] No RPC endpoint configured for chainId: ${this.chainId}`);
+        }
+        // Get the entry for the current chainId from the gatewayConfig
+        const config = this.gatewayConfig[this.chainId];
+        if (typeof config === 'string') {
+            return config;
+        }
+        // If we got this far, there's no way to support the chain with the current config
+        throw new Error(`[PortalProvider] Could not find a valid gatewayConfig entry for chainId: ${this.chainId}`);
+    }
+    /**************************
+     * RPC Encoding Methods
+     **************************/
+    stringToHex(str) {
+        if (str.startsWith('0x')) {
+            return str;
+        }
+        let hex = '0x';
+        for (let i = 0; i < str.length; i++) {
+            const charCode = str.charCodeAt(i);
+            const hexValue = charCode.toString(16);
+            hex += hexValue.padStart(2, '0'); // Ensure two-digit hex value
+        }
+        return hex;
+    }
+}
+export default Portal;

package/lib/esm/mpc/index.js

@@ -0,0 +1,351 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PortalMpcError } from '@portal-hq/utils';
+const WEB_SDK_VERSION = '0.0.1-beta-1';
+class Mpc {
+    constructor({ apiKey, chainId, portal, rpcUrl, 
+    // Optional
+    apiHost = 'api.portalhq.io', autoApprove = false, mpcHost = 'mpc.portalhq.io', webHost = 'web.portalhq.io', }) {
+        this.apiHost = apiHost;
+        this.apiKey = apiKey;
+        this.autoApprove = autoApprove;
+        this.chainId = chainId;
+        this.mpcHost = mpcHost;
+        this.portal = portal;
+        this.rpcUrl = rpcUrl;
+        this.webHost = webHost;
+        // Handle scoping of certain functions
+        this.configureIframe = this.configureIframe.bind(this);
+        // Create the iFrame for MPC operations
+        this.appendIframe();
+    }
+    // In Progress
+    backup(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:wasm:backup',
+                data,
+            };
+            return new Promise((resolve, reject) => {
+                // Create a function to be bound when backup is triggered
+                const handleBackup = (event) => {
+                    const { type, data: result } = event;
+                    // Check that the message is the one we're looking for
+                    if (type === 'portal:wasm:backupResult') {
+                        // Check if the result is an error
+                        if (result.error && result.error.code > 0) {
+                            // Remove the event listener
+                            window.removeEventListener('message', handleBackup);
+                            // Reject the promise with the error
+                            return reject(new PortalMpcError(result.error));
+                        }
+                        // Remove the event listener
+                        window.removeEventListener('message', handleBackup);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleBackup);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    // In Progress
+    decrypt(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:wasm:decrypt',
+                data,
+            };
+            return new Promise((resolve, reject) => {
+                const handleDecrypt = (event) => {
+                    const { type, data: result } = event;
+                    // Check that the message is the one we're looking for
+                    if (type === 'portal:wasm:decryptResult') {
+                        // Check if the result is an error
+                        if (result.error && result.error.code > 0) {
+                            // Remove the event listener
+                            window.removeEventListener('message', handleDecrypt);
+                            // Reject the promise with the error
+                            return reject(new PortalMpcError(result.error));
+                        }
+                        // Remove the event listener
+                        window.removeEventListener('message', handleDecrypt);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleDecrypt);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    // In Progress
+    encrypt(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:wasm:encrypt',
+                data,
+            };
+            return new Promise((resolve, reject) => {
+                const handleEncrypt = (event) => {
+                    const { type, data: result } = event;
+                    // Check that the message is the one we're looking for
+                    if (type === 'portal:wasm:encryptResult') {
+                        // Check if the result is an error
+                        if (result.error && result.error.code > 0) {
+                            // Remove the event listener
+                            window.removeEventListener('message', handleEncrypt);
+                            // Reject the promise with the error
+                            return reject(new PortalMpcError(result.error));
+                        }
+                        // Remove the event listener
+                        window.removeEventListener('message', handleEncrypt);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleEncrypt);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    generate(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:wasm:generate',
+                data,
+            };
+            return new Promise((resolve, reject) => {
+                // Create a function to be bound when generate is triggered
+                const handleGenerate = (event) => {
+                    console.log(`[MPC] Temporary listener received event: `, event);
+                    const { type, data: result } = event.data;
+                    // Handle errors
+                    if (type === 'portal:wasm:generateError') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGenerate);
+                        // Reject the promise with the error
+                        return reject(new PortalMpcError(result));
+                    }
+                    else if (type === 'portal:wasm:generateResult') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGenerate);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleGenerate);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:address',
+                data: {},
+            };
+            return new Promise((resolve) => {
+                // Create a function to be bound when getAddress is triggered
+                const handleGetAddress = (event) => {
+                    const { type, data: result } = event.data;
+                    // Check that the message is the one we're looking for
+                    if (type === 'portal:addressResult') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetAddress);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleGetAddress);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    // In Progress
+    recover(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.recoverBackup(data);
+            // TODO: Write the DKG Result to local storage
+            const cipherText = yield this.recoverSigning(data);
+            return JSON.stringify(cipherText);
+        });
+    }
+    // In Progress
+    recoverBackup(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:wasm:recoverBackup',
+                data,
+            };
+            return new Promise((resolve, reject) => {
+                // Create a function to be bound when recoverSigning is triggered
+                const handleRecovery = (event) => {
+                    const { type, data: result } = event;
+                    // Check that the message is the one we're looking for
+                    if (type === 'portal:wasm:recoverBackupResult') {
+                        // Check if the result is an error
+                        if (result.error && result.error.code > 0) {
+                            // Remove the event listener
+                            window.removeEventListener('message', handleRecovery);
+                            // Reject the promise with the error
+                            return reject(new PortalMpcError(result.error));
+                        }
+                        // Remove the event listener
+                        window.removeEventListener('message', handleRecovery);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleRecovery);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    // In Progress
+    recoverSigning(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:wasm:recoverSigning',
+                data,
+            };
+            return new Promise((resolve, reject) => {
+                // Create a function to be bound when recoverSigning is triggered
+                const handleRecovery = (event) => {
+                    const { type, data: result } = event;
+                    // Check that the message is the one we're looking for
+                    if (type === 'portal:wasm:recoverSigningResult') {
+                        // Check if the result is an error
+                        if (result.error && result.error.code > 0) {
+                            // Remove the event listener
+                            window.removeEventListener('message', handleRecovery);
+                            // Reject the promise with the error
+                            return reject(new PortalMpcError(result.error));
+                        }
+                        // Remove the event listener
+                        window.removeEventListener('message', handleRecovery);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleRecovery);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    sign(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = {
+                type: 'portal:wasm:sign',
+                data,
+            };
+            return new Promise((resolve, reject) => {
+                // Create a function to be bound when sign is triggered
+                const handleSign = (event) => {
+                    const { type, data: result } = event.data;
+                    if (type === 'portal:wasm:signError') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleSign);
+                        // Reject the promise with the error
+                        return reject(new PortalMpcError(result));
+                    }
+                    else if (type === 'portal:wasm:signResult') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleSign);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleSign);
+                // Send the request to the iframe
+                this.postMessage(message);
+            });
+        });
+    }
+    /***************************
+     * Private Methods
+     ***************************/
+    /**
+     * Appends the iframe to the document body
+     */
+    appendIframe() {
+        const source = this.webHost.startsWith('locahost:')
+            ? `http://${this.webHost}/${WEB_SDK_VERSION}/iframe/index.html?t=${Date.now()}`
+            : `https://${this.webHost}/${WEB_SDK_VERSION}/iframe/index.html?t=${Date.now()}`;
+        const iframe = document.createElement('iframe');
+        iframe.height = '0';
+        iframe.width = '0';
+        iframe.src = source;
+        iframe.addEventListener('load', this.configureIframe);
+        document.body.appendChild(iframe);
+        this.iframe = iframe;
+    }
+    configureIframe() {
+        const config = {
+            apiHost: this.apiHost,
+            apiKey: this.apiKey,
+            autoApprove: this.autoApprove,
+            chainId: this.chainId,
+            mpcHost: this.mpcHost,
+            rpcUrl: this.rpcUrl,
+        };
+        const message = {
+            type: 'portal:configure',
+            data: config
+        };
+        this.postMessage(message);
+        this.waitForReadyMessage();
+    }
+    getOrigin() {
+        const origin = this.webHost.startsWith('localhost:')
+            ? `http://${this.webHost}`
+            : `https://${this.webHost}`;
+        return origin;
+    }
+    postMessage(event) {
+        var _a, _b, _c;
+        console.log(`[MpcProxy] Sending new message: `, event, (_a = this.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow);
+        (_c = (_b = this.iframe) === null || _b === void 0 ? void 0 : _b.contentWindow) === null || _c === void 0 ? void 0 : _c.postMessage(event, this.getOrigin());
+    }
+    waitForReadyMessage() {
+        const handleReady = (message) => __awaiter(this, void 0, void 0, function* () {
+            const { type, data } = message.data;
+            if (type === 'portal:wasm:ready' && data === true) {
+                // Unbind the event listener
+                window.removeEventListener('message', handleReady);
+                // Update ready state
+                this.portal.ready = true;
+                // Update the address
+                const address = yield this.getAddress();
+                this.portal.address = address;
+                // Trigger the ready callback
+                this.portal.triggerReady();
+            }
+        });
+        window.addEventListener('message', handleReady);
+    }
+}
+export default Mpc;