@portal-hq/web 0.0.1-beta-1

package/lib/commonjs/mpc/index.js

@@ -0,0 +1,353 @@
+"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 });
+const utils_1 = require("@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 utils_1.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 utils_1.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 utils_1.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 utils_1.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 utils_1.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 utils_1.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 utils_1.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);
+    }
+}
+exports.default = Mpc;

package/lib/commonjs/provider/index.js

@@ -0,0 +1,259 @@
+"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 });
+const utils_1 = require("@portal-hq/utils");
+const passiveSignerMethods = [
+    'eth_accounts',
+    'eth_chainId',
+    'eth_requestAccounts',
+];
+const signerMethods = [
+    'eth_accounts',
+    'eth_chainId',
+    'eth_requestAccounts',
+    'eth_sendTransaction',
+    'eth_sign',
+    'eth_signTransaction',
+    'eth_signTypedData_v3',
+    'eth_signTypedData_v4',
+    'personal_sign',
+];
+class Provider {
+    constructor({ autoApprove = false, portal, }) {
+        this.autoApprove = autoApprove;
+        this.events = {};
+        this.portal = portal;
+    }
+    /**
+     * Invokes all registered event handlers with the data provided
+     * - If any `once` handlers exist, they are removed after all handlers are invoked
+     *
+     * @param event The name of the event to be handled
+     * @param data The data to be passed to registered event handlers
+     * @returns BaseProvider
+     */
+    emit(event, data) {
+        // Grab the registered event handlers if any are available
+        const handlers = this.events[event] || [];
+        // Execute every event handler
+        for (const registeredEventHandler of handlers) {
+            registeredEventHandler.handler(data);
+        }
+        // Remove any registered event handlers with the `once` flag
+        this.events[event] = handlers.filter((handler) => !handler.once);
+        return this;
+    }
+    /**
+     * Registers an event handler for the provided event
+     *
+     * @param event The event name to add a handler to
+     * @param callback The callback to be invoked when the event is emitted
+     * @returns BaseProvider
+     */
+    on(event, callback) {
+        // If no handlers are registered for this event, create an entry for the event
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        // Register event handler with the rudimentary event bus
+        if (typeof callback !== 'undefined') {
+            this.events[event].push({
+                handler: callback,
+                once: false,
+            });
+        }
+        return this;
+    }
+    removeEventListener(event, listenerToRemove) {
+        if (!this.events[event]) {
+            return;
+        }
+        if (!listenerToRemove) {
+            this.events[event] = [];
+        }
+        else {
+            const filterEventHandlers = (registeredEventHandler) => {
+                return registeredEventHandler.handler !== listenerToRemove;
+            };
+            this.events[event] = this.events[event].filter(filterEventHandlers);
+        }
+    }
+    /**
+     * Handles request routing in compliance with the EIP-1193 Ethereum Javascript Provider API
+     * - See here for more info: https://eips.ethereum.org/EIPS/eip-1193
+     *
+     * @param args The arguments of the request being made
+     * @returns Promise<any>
+     */
+    request({ method, params }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (method === 'eth_chainId') {
+                return this.portal.chainId;
+            }
+            const isSignerMethod = signerMethods.includes(method);
+            let result;
+            if (!isSignerMethod && !method.startsWith('wallet_')) {
+                // Send to Gateway for RPC calls
+                const response = yield this.handleGatewayRequest({ method, params });
+                this.emit('portal_signatureReceived', {
+                    method,
+                    params,
+                    signature: response,
+                });
+                if (response.error) {
+                    throw new utils_1.ProviderRpcError(response.error);
+                }
+                result = response.result;
+            }
+            else if (isSignerMethod) {
+                // Handle signing
+                const transactionHash = yield this.handleSigningRequest({
+                    method,
+                    params,
+                });
+                if (transactionHash) {
+                    this.emit('portal_signatureReceived', {
+                        method,
+                        params,
+                        signature: transactionHash,
+                    });
+                    result = transactionHash;
+                }
+            }
+            else {
+                // Unsupported method
+                throw new utils_1.ProviderRpcError({
+                    code: utils_1.RpcErrorCodes.UnsupportedMethod,
+                    data: {
+                        method,
+                        params,
+                    },
+                });
+            }
+            return result;
+        });
+    }
+    /************************
+     * Private Methods
+     ************************/
+    /**
+     * Kicks off the approval flow for a given request
+     *
+     * @param args The arguments of the request being made
+     */
+    getApproval({ method, params, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If autoApprove is enabled, just resolve to true
+            if (this.autoApprove) {
+                return true;
+            }
+            const signingHandlers = this.events['portal_signingRequested'];
+            if (!signingHandlers || signingHandlers.length === 0) {
+                throw new Error(`[PortalProvider] Auto-approve is disabled. Cannot perform signing requests without an event handler for the 'portal_signingRequested' event.`);
+            }
+            return new Promise((resolve) => {
+                // Remove already used listeners
+                this.removeEventListener('portal_signingApproved');
+                this.removeEventListener('portal_signingRejected');
+                const handleApproval = ({ method: approvedMethod, params: approvedParams }) => {
+                    // Remove already used listeners
+                    this.removeEventListener('portal_signingApproved');
+                    this.removeEventListener('portal_signingRejected');
+                    // First verify that this is the same signing request
+                    if (method === approvedMethod &&
+                        JSON.stringify(params) === JSON.stringify(approvedParams)) {
+                        resolve(true);
+                    }
+                };
+                const handleRejection = ({ method: rejectedMethod, params: rejectedParams }) => {
+                    // Remove already used listeners
+                    this.removeEventListener('portal_signingApproved');
+                    this.removeEventListener('portal_signingRejected');
+                    // First verify that this is the same signing request
+                    if (method === rejectedMethod &&
+                        JSON.stringify(params) === JSON.stringify(rejectedParams)) {
+                        resolve(false);
+                    }
+                };
+                // If the signing has been approved, resolve to true
+                this.on('portal_signingApproved', handleApproval);
+                // If the signing request has been rejected, resolve to false
+                this.on('portal_signingRejected', handleRejection);
+                // Tell any listening clients that signing has been requested
+                this.emit('portal_signingRequested', {
+                    method,
+                    params,
+                });
+            });
+        });
+    }
+    /**
+     * Sends the provided request payload along to the RPC HttpRequester
+     *
+     * @param args The arguments of the request being made
+     * @returns Promise<any>
+     */
+    handleGatewayRequest({ method, params, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Pass request off to the gateway
+            const result = yield fetch(this.portal.getRpcUrl(), {
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: this.portal.chainId,
+                    method,
+                    params,
+                }),
+                method: 'POST',
+            });
+            return result.json();
+        });
+    }
+    /**
+     * Sends the provided request payload along to the Signer
+     *
+     * @param args The arguments of the request being made
+     * @returns Promise<any>
+     */
+    handleSigningRequest({ method, params, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isApproved = passiveSignerMethods.includes(method)
+                ? true
+                : yield this.getApproval({ method, params });
+            if (!isApproved) {
+                console.info(`[PortalProvider] Request for signing method '${method}' could not be completed because it was not approved by the user.`);
+                return;
+            }
+            switch (method) {
+                case 'eth_chainId':
+                    return `0x${this.portal.chainId.toString(16)}`;
+                case 'eth_accounts':
+                case 'eth_requestAccounts':
+                    return [this.portal.address];
+                case 'eth_sendTransaction':
+                case 'eth_sign':
+                case 'eth_signTransaction':
+                case 'eth_signTypedData_v3':
+                case 'eth_signTypedData_v4':
+                case 'personal_sign':
+                    const result = yield this.portal.mpc.sign({
+                        host: this.portal.mpcHost,
+                        method,
+                        mpcVersion: this.portal.mpcVersion,
+                        params,
+                    });
+                    return result;
+                default:
+                    throw new Error('[PortalProvider] Method "' + method + '" not supported');
+            }
+        });
+    }
+}
+exports.default = Provider;

package/lib/commonjs/storage/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DefaultBackupStorage {
+    delete() {
+        throw new Error('[Portal] Storage method delete cannot be called directly. Please extend Storage.');
+    }
+    read() {
+        throw new Error('[Portal] Storage method read cannot be called directly. Please extend Storage.');
+    }
+    write(privateKey) {
+        throw new Error(`[Portal] Storage method write(${privateKey}) cannot be called directly. Please extend Storage.`);
+    }
+    validateOperations() {
+        throw new Error('[Portal] Storage method validateOperations cannot be called directly. Please extend Storage.');
+    }
+}
+exports.default = DefaultBackupStorage;