@portal-hq/web 0.0.1-beta-1

package/lib/esm/provider/index.js

@@ -0,0 +1,257 @@
+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 { ProviderRpcError, RpcErrorCodes } from '@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 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 ProviderRpcError({
+                    code: 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');
+            }
+        });
+    }
+}
+export default Provider;

package/lib/esm/storage/index.js

@@ -0,0 +1,15 @@
+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.');
+    }
+}
+export default DefaultBackupStorage;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@portal-hq/web",
+  "description": "Portal MPC Support for Web",
+  "author": "Portal Labs, Inc.",
+  "homepage": "https://portalhq.io/",
+  "version": "0.0.1-beta-1",
+  "license": "MIT",
+  "main": "lib/commonjs/index",
+  "module": "lib/esm/index",
+  "source": "src/index",
+  "types": "src/index",
+  "files": [
+    "src",
+    "lib",
+    "types.d.ts",
+    "!src/iframe"
+  ],
+  "scripts": {
+    "bundle": "sh ./scripts/version-iframe.sh && webpack && sh ./scripts/copy-static-files.sh && git stash",
+    "coverage": "jest --collect-coverage",
+    "prepare": "sh ./scripts/version-mpc.sh && yarn prepare:cjs && yarn prepare:esm && rm -rf lib/esm/iframe && rm -rf lib/commonjs/iframe",
+    "prepare:cjs": "tsc --outDir lib/commonjs --module commonjs",
+    "prepare:esm": "tsc --outDir lib/esm --module es2015 --target es2015",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@portal-hq/utils": "^1.0.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.22.5",
+    "@babel/preset-env": "^7.22.5",
+    "@babel/preset-typescript": "^7.18.6",
+    "@types/jest": "^29.2.0",
+    "@types/react": "*",
+    "@types/react-native": "^0.70.5",
+    "babel-loader": "^9.1.2",
+    "jest": "^29.2.1",
+    "jest-environment-jsdom": "^29.2.2",
+    "terser-webpack-plugin": "^5.3.9",
+    "ts-jest": "^29.0.3",
+    "ts-loader": "^9.4.3",
+    "typescript": "^4.8.4",
+    "webpack": "^5.87.0",
+    "webpack-cli": "^5.1.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1,232 @@
+import type { BackupOptions, EthereumTransaction, GatewayLike, PortalOptions, TypedData } from '../types'
+import Mpc from './mpc'
+import Provider from './provider'
+import DefaultBackupStorage from './storage'
+
+class Portal {
+    public address?: string
+    public chainId: number
+    public mpc: Mpc
+    public mpcHost: string
+    public mpcVersion: string
+    public provider: Provider
+    public ready: boolean = false
+
+    private apiHost: string
+    private apiKey: string
+    private autoApprove: boolean
+    private backup: BackupOptions
+    private gatewayConfig: GatewayLike
+    private readyCallbacks: (() => any | Promise<any>)[] = []
+    private rpcUrl: string
+    private webHost: string
+
+    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',
+    }: PortalOptions) {
+        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
+     *****************************/
+
+    public onReady(callback: () => any | Promise<any>) {
+        if (this.ready) {
+            callback()
+        } else {
+            this.readyCallbacks.push(callback)
+        }
+    }
+
+    public triggerReady() {
+        if (this.ready && this.readyCallbacks.length > 0) {
+            this.readyCallbacks.forEach((callback) => {
+                callback()
+            })
+
+            this.readyCallbacks = []
+        }
+    }
+
+    /*****************************
+     * Wallet Methods
+     *****************************/
+
+    public async createWallet(): Promise<string> {
+      const address = await this.mpc.generate({
+        host: this.mpcHost,
+        mpcVersion: this.mpcVersion,
+      })
+
+      this.address = address
+
+      return address
+    }
+
+    public async backupWallet(): Promise<string> {
+        await this.mpc.backup({
+            host: this.mpcHost,
+            mpcVersion: this.mpcVersion,
+        })
+
+        return ''
+    }
+
+    public async recoverWallet(): Promise<boolean> {
+        await this.mpc.recover({
+            host: this.mpcHost,
+            mpcVersion: this.mpcVersion,
+        })
+
+        return true
+    }
+
+    /****************************
+     * Provider Methods
+     ****************************/
+
+    public async ethSendTransaction(transaction: EthereumTransaction): Promise<string> {
+        return this.provider.request({
+            method: 'eth_sendTransaction',
+            params: transaction,
+        })
+    }
+
+    public async ethSign(message: string): Promise<string> {
+        return this.provider.request({
+            method: 'eth_sign',
+            params: [this.address, this.stringToHex(message)],
+        })
+    }
+
+    public async ethSignTransaction(transaction: EthereumTransaction): Promise<string> {
+        return this.provider.request({
+            method: 'eth_signTransaction',
+            params: transaction,
+        })
+    }
+
+    public async ethSignTypedData(data: TypedData): Promise<string> {
+        return this.provider.request({
+            method: 'eth_signTypedData',
+            params: [this.address, data],
+        })
+    }
+
+    public async ethSignTypedDataV3(data: TypedData): Promise<string> {
+        return this.provider.request({
+            method: 'eth_signTypedData_v3',
+            params: [this.address, data],
+        })
+
+    }
+
+    public async ethSignTypedDataV4(data: TypedData): Promise<string> {
+        return this.provider.request({
+            method: 'eth_signTypedData_v4',
+            params: [this.address, data],
+        })
+    }
+
+    public async personalSign(message: string): Promise<string> {
+        return this.provider.request({
+            method: 'personal_sign', 
+            params: [this.stringToHex(message), this.address],
+        })
+    }
+
+    /****************************
+     * RPC Methods
+     ****************************/
+
+    public 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
+     **************************/
+
+    private stringToHex(str: string): string {
+        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