@portal-hq/provider 0.2.0-beta10

package/lib/commonjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provider = void 0;
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return __importDefault(providers_1).default; } });

package/lib/commonjs/providers/index.js

@@ -0,0 +1,383 @@
+"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 requesters_1 = require("../requesters");
+const signers_1 = require("../signers");
+const passiveSignerMethods = [
+    'eth_accounts',
+    'eth_chainId',
+    'eth_requestAccounts',
+];
+const signerMethods = [
+    'eth_accounts',
+    'eth_chainId',
+    'eth_requestAccounts',
+    'eth_sendTransaction',
+    'eth_sign',
+    'eth_signTransaction',
+    'eth_signTypedData',
+    'personal_sign',
+];
+class Provider {
+    constructor({ 
+    // Required options
+    apiKey, chainId, keychain, 
+    // Optional options
+    apiUrl = 'api.portalhq.io', autoApprove = false, enableMpc = true, mpcUrl = 'mpc.portalhq.io', gatewayConfig = {}, }) {
+        // Handle required fields
+        if (!apiKey || apiKey.length === 0) {
+            throw new utils_1.InvalidApiKeyError();
+        }
+        if (!chainId) {
+            throw new utils_1.InvalidChainIdError();
+        }
+        if (!gatewayConfig) {
+            throw new utils_1.InvalidGatewayConfigError();
+        }
+        // Handle the stuff we can auto-set
+        this.apiKey = apiKey;
+        this.apiUrl = apiUrl;
+        this.autoApprove = autoApprove;
+        this.chainId = chainId;
+        this.events = {};
+        this.isMPC = enableMpc;
+        this.keychain = keychain;
+        this.log = console;
+        this.mpcUrl = mpcUrl;
+        this.portal = new requesters_1.HttpRequester({
+            baseUrl: this.apiUrl,
+        });
+        // Handle RPC Initialization
+        this.gatewayConfig = gatewayConfig;
+        this.rpc = new requesters_1.HttpRequester({
+            baseUrl: this.getRpcUrl(),
+        });
+        if (this.isMPC) {
+            // If MPC is enabled, initialize an MpcSigner
+            this.signer = new signers_1.MpcSigner({
+                mpcUrl: this.mpcUrl,
+                keychain: this.keychain,
+            });
+        }
+        else {
+            // If MPC is disabled, initialize an HttpSigner, talking to whatever httpHost was provided
+            this.signer = new signers_1.HttpSigner({
+                portal: this.portal,
+            });
+        }
+        this.dispatchConnect();
+    }
+    get address() {
+        return this._address;
+    }
+    set address(value) {
+        this._address = value;
+        if (this.signer && this.isMPC) {
+            ;
+            this.signer._address = value;
+        }
+    }
+    get rpcUrl() {
+        return this.getRpcUrl();
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Registers a single-execution event handler for the provided event
+     *
+     * @param event The event name to add a handler to
+     * @param callback The callback to be invoked the next time the event is emitted
+     * @returns BaseProvider
+     */
+    once(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: true,
+            });
+        }
+        return this;
+    }
+    removeEventListener(event, listenerToRemove) {
+        if (!this.events[event]) {
+            this.log.info(`[PortalProvider] Attempted to remove a listener from unregistered event '${event}'. Ignoring.`);
+            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.chainId;
+            }
+            const isSignerMethod = signerMethods.includes(method);
+            let result;
+            if (!isSignerMethod && !method.startsWith('wallet_')) {
+                // Send to Gateway for RPC calls
+                const response = yield this.handleGatewayRequests({ 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.handleSigningRequests({
+                    method,
+                    params,
+                });
+                if (transactionHash) {
+                    console.log(`Received transaction hash: `, 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;
+        });
+    }
+    /**
+     * Updates the chainId of this instance and builds a new RPC HttpRequester for
+     * the gateway used for the new chain
+     *
+     * @param chainId A hex string of the chainId to use for this connection
+     * @returns BaseProvider
+     */
+    updateChainId(chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.chainId = Number(`${chainId}`);
+            this.rpc = new requesters_1.HttpRequester({
+                baseUrl: this.getRpcUrl(),
+            });
+            this.emit('chainChanged', { chainId });
+            return this;
+        });
+    }
+    /**
+     * 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;
+            }
+            if (!this.events['portal_signingRequested']) {
+                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');
+                // If the signing has been approved, resolve to true
+                this.once('portal_signingApproved', ({ method: approvedMethod, params: approvedParams }) => {
+                    console.log(`[PortalProvider] Signing Approved`, method, params);
+                    // 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);
+                    }
+                });
+                // If the signing request has been rejected, resolve to false
+                this.once('portal_signingRejected', ({ method: rejectedMethod, params: rejectedParams }) => {
+                    console.log(`[PortalProvider] Signing Approved`, method, params);
+                    // 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);
+                    }
+                });
+                // Tell any listening clients that signing has been requested
+                this.emit('portal_signingRequested', {
+                    method,
+                    params,
+                });
+            });
+        });
+    }
+    dispatchConnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`[PortalProvider] Connected on chainId: 0x${this.chainId.toString(16)}`);
+            this.emit('connect', {
+                chainId: `0x${this.chainId.toString(16)}`,
+            });
+        });
+    }
+    dispatchDisconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.emit('disconnect', {
+                error: new utils_1.ProviderRpcError({
+                    code: utils_1.RpcErrorCodes.Disconnected,
+                }),
+            });
+        });
+    }
+    /**
+     * Determines the RPC URL to be used for the current chain
+     *
+     * @returns string
+     */
+    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}`);
+    }
+    /**
+     * Sends the provided request payload along to the RPC HttpRequester
+     *
+     * @param args The arguments of the request being made
+     * @returns Promise<any>
+     */
+    handleGatewayRequests({ method, params, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Pass request off to the gateway
+            return yield this.rpc.post('', {
+                body: {
+                    jsonrpc: '2.0',
+                    id: this.chainId,
+                    method,
+                    params,
+                },
+            });
+        });
+    }
+    /**
+     * Sends the provided request payload along to the Signer
+     *
+     * @param args The arguments of the request being made
+     * @returns Promise<any>
+     */
+    handleSigningRequests({ method, params, }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const isApproved = passiveSignerMethods.includes(method)
+                ? true
+                : yield this.getApproval({ method, params });
+            if (!isApproved) {
+                this.log.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.chainId.toString(16)}`;
+                case 'eth_accounts':
+                case 'eth_requestAccounts':
+                case 'eth_sendTransaction':
+                case 'eth_sign':
+                case 'eth_signTransaction':
+                case 'eth_signTypedData':
+                case 'personal_sign':
+                    return yield ((_a = this.signer) === null || _a === void 0 ? void 0 : _a.sign({ chainId: this.chainId, method, params }, this));
+                default:
+                    throw new Error('[PortalProvider] Method "' + method + '" not supported');
+            }
+        });
+    }
+}
+exports.default = Provider;

package/lib/commonjs/requesters/http.js

@@ -0,0 +1,52 @@
+"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");
+class HttpRequester {
+    constructor({ baseUrl }) {
+        this.baseUrl = baseUrl.startsWith('https://')
+            ? baseUrl
+            : `https://${baseUrl}`;
+    }
+    get(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = {
+                method: 'GET',
+                url: `${this.baseUrl}${path}`,
+            };
+            if (options && options.headers) {
+                requestOptions.headers = this.buildHeaders(options.headers);
+            }
+            const request = new utils_1.HttpRequest(requestOptions);
+            const response = (yield request.send());
+            return response;
+        });
+    }
+    post(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = {
+                method: 'POST',
+                url: `${this.baseUrl}${path}`,
+            };
+            requestOptions.headers = this.buildHeaders(options && options.headers ? options.headers : {});
+            if (options && options.body) {
+                requestOptions.body = options.body;
+            }
+            const request = new utils_1.HttpRequest(requestOptions);
+            const response = (yield request.send());
+            return response;
+        });
+    }
+    buildHeaders(headers) {
+        return Object.assign({ 'Content-Type': 'application/json' }, headers);
+    }
+}
+exports.default = HttpRequester;

package/lib/commonjs/requesters/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequester = void 0;
+var http_1 = require("./http");
+Object.defineProperty(exports, "HttpRequester", { enumerable: true, get: function () { return __importDefault(http_1).default; } });

package/lib/commonjs/signers/abstract.js

@@ -0,0 +1,19 @@
+"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 Signer {
+    sign(message, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('[Portal] sign() method must be implemented in a child of BaseSigner');
+        });
+    }
+}
+exports.default = Signer;

package/lib/commonjs/signers/http.js

@@ -0,0 +1,58 @@
+"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 keychain_1 = require("@portal-hq/keychain");
+const utils_1 = require("@portal-hq/utils");
+class HttpSigner {
+    constructor(opts) {
+        if (!opts.portal) {
+            throw new utils_1.MissingOptionError({
+                className: 'HttpSigner',
+                option: 'portal',
+            });
+        }
+        this.keychain = new keychain_1.Keychain();
+        this.portal = opts.portal;
+    }
+    sign(message, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.keychain.getAddress();
+            const arrayMethods = ['personal_sign'];
+            const { chainId, method, params } = message;
+            switch (method) {
+                case 'eth_requestAccounts':
+                    return [address];
+                case 'eth_accounts':
+                    return [address];
+                default:
+                    break;
+            }
+            console.log(`[Portal:HttpSigner] Requesting signature from exchange for:`, JSON.stringify({
+                chainId,
+                method,
+                params: JSON.stringify([params]),
+            }, null, 2));
+            const signatureResponse = yield this.portal.post('/api/v1/clients/transactions/sign', {
+                body: {
+                    chainId,
+                    method,
+                    params: JSON.stringify([params]),
+                },
+                headers: {
+                    Authorization: `Bearer ${provider.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            return signatureResponse;
+        });
+    }
+}
+exports.default = HttpSigner;

package/lib/commonjs/signers/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MpcSigner = exports.HttpSigner = exports.Signer = void 0;
+var abstract_1 = require("./abstract");
+Object.defineProperty(exports, "Signer", { enumerable: true, get: function () { return __importDefault(abstract_1).default; } });
+var http_1 = require("./http");
+Object.defineProperty(exports, "HttpSigner", { enumerable: true, get: function () { return __importDefault(http_1).default; } });
+var mpc_1 = require("./mpc");
+Object.defineProperty(exports, "MpcSigner", { enumerable: true, get: function () { return __importDefault(mpc_1).default; } });

package/lib/commonjs/signers/mpc.js

@@ -0,0 +1,75 @@
+"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 react_native_1 = require("react-native");
+const utils_1 = require("@portal-hq/utils");
+class MpcSigner {
+    constructor(opts) {
+        this.buildParams = (method, txParams) => {
+            let params = txParams;
+            switch (method) {
+                case 'eth_sign':
+                case 'personal_sign':
+                    if (!Array.isArray(txParams)) {
+                        params = [txParams];
+                    }
+                    break;
+                default:
+                    if (Array.isArray(txParams)) {
+                        params = txParams[0];
+                    }
+            }
+            return params;
+        };
+        this.keychain = opts.keychain;
+        this.mpc = react_native_1.NativeModules.PortalMobileMpc;
+        this.mpcUrl = opts.mpcUrl;
+        if (!this.mpc) {
+            throw new Error(`[Portal.Provider.MpcSigner] The MPC module could not be found by the signer. This is usually an issue with React Native linking. Please verify that the 'PortalReactNative' module is properly linked to this project.`);
+        }
+    }
+    get address() {
+        return (() => __awaiter(this, void 0, void 0, function* () {
+            if (this._address) {
+                return this._address;
+            }
+            const address = yield this.keychain.getAddress();
+            this._address = address;
+            return address;
+        }))();
+    }
+    sign(message, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.keychain.getAddress();
+            const apiKey = provider.apiKey;
+            const { method, params } = message;
+            switch (method) {
+                case 'eth_requestAccounts':
+                    return [address];
+                case 'eth_accounts':
+                    return [address];
+                default:
+                    break;
+            }
+            console.log(`[Portal:MpcSigner] Requesting signature from PortalMobileMpc for:`, JSON.stringify(message, null, 2));
+            const dkg = yield this.keychain.getDkgResult();
+            console.log(`[PortalMpcSigner] RPC URL: ${provider.rpcUrl}`);
+            const result = yield this.mpc.sign(apiKey, this.mpcUrl, dkg, message.method, JSON.stringify(this.buildParams(method, params)), provider.rpcUrl, provider.chainId.toString());
+            console.log(`[PortalMpcSigner] Result: `, result);
+            const { data, error } = JSON.parse(String(result));
+            if (error && error.length) {
+                throw new utils_1.MpcSigningError(error);
+            }
+            return data;
+        });
+    }
+}
+exports.default = MpcSigner;

package/lib/esm/index.js

@@ -0,0 +1 @@
+export { default as Provider } from './providers';