@portal-hq/provider 0.2.11 → 0.2.12

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,376 @@
+"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 = {}, }) {
+        this._address = '';
+        // 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({
+                keychain: this.keychain,
+                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)}`,
+            });
+        });
+    }
+    /**
+     * 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(_, __) {
+        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,56 @@
+"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 HttpSigner {
+    constructor(opts) {
+        if (!opts.portal) {
+            throw new utils_1.MissingOptionError({
+                className: 'HttpSigner',
+                option: 'portal',
+            });
+        }
+        this.keychain = opts.keychain;
+        this.portal = opts.portal;
+    }
+    sign(message, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.keychain.getAddress();
+            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,76 @@
+"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._address = '';
+        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';

package/lib/esm/providers/index.js

@@ -0,0 +1,374 @@
+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 { InvalidApiKeyError, InvalidChainIdError, InvalidGatewayConfigError, ProviderRpcError, RpcErrorCodes, } from '@portal-hq/utils';
+import { HttpRequester } from '../requesters';
+import { HttpSigner, MpcSigner } from '../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 = {}, }) {
+        this._address = '';
+        // Handle required fields
+        if (!apiKey || apiKey.length === 0) {
+            throw new InvalidApiKeyError();
+        }
+        if (!chainId) {
+            throw new InvalidChainIdError();
+        }
+        if (!gatewayConfig) {
+            throw new 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 HttpRequester({
+            baseUrl: this.apiUrl,
+        });
+        // Handle RPC Initialization
+        this.gatewayConfig = gatewayConfig;
+        this.rpc = new HttpRequester({
+            baseUrl: this.getRpcUrl(),
+        });
+        if (this.isMPC) {
+            // If MPC is enabled, initialize an MpcSigner
+            this.signer = new MpcSigner({
+                mpcUrl: this.mpcUrl,
+                keychain: this.keychain,
+            });
+        }
+        else {
+            // If MPC is disabled, initialize an HttpSigner, talking to whatever httpHost was provided
+            this.signer = new HttpSigner({
+                keychain: this.keychain,
+                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 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 ProviderRpcError({
+                    code: 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 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)}`,
+            });
+        });
+    }
+    /**
+     * 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');
+            }
+        });
+    }
+}
+export default Provider;

package/lib/esm/requesters/http.js

@@ -0,0 +1,50 @@
+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 { HttpRequest, } from '@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 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 HttpRequest(requestOptions);
+            const response = (yield request.send());
+            return response;
+        });
+    }
+    buildHeaders(headers) {
+        return Object.assign({ 'Content-Type': 'application/json' }, headers);
+    }
+}
+export default HttpRequester;

package/lib/esm/requesters/index.js

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

package/lib/esm/signers/abstract.js

@@ -0,0 +1,17 @@
+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());
+    });
+};
+class Signer {
+    sign(_, __) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('[Portal] sign() method must be implemented in a child of BaseSigner');
+        });
+    }
+}
+export default Signer;

package/lib/esm/signers/http.js

@@ -0,0 +1,54 @@
+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 { MissingOptionError, } from '@portal-hq/utils';
+class HttpSigner {
+    constructor(opts) {
+        if (!opts.portal) {
+            throw new MissingOptionError({
+                className: 'HttpSigner',
+                option: 'portal',
+            });
+        }
+        this.keychain = opts.keychain;
+        this.portal = opts.portal;
+    }
+    sign(message, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.keychain.getAddress();
+            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;
+        });
+    }
+}
+export default HttpSigner;

package/lib/esm/signers/index.js

@@ -0,0 +1,3 @@
+export { default as Signer } from './abstract';
+export { default as HttpSigner } from './http';
+export { default as MpcSigner } from './mpc';

package/lib/esm/signers/mpc.js

@@ -0,0 +1,74 @@
+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 { NativeModules } from 'react-native';
+import { MpcSigningError, } from '@portal-hq/utils';
+class MpcSigner {
+    constructor(opts) {
+        this._address = '';
+        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 = 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 MpcSigningError(error);
+            }
+            return data;
+        });
+    }
+}
+export default MpcSigner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portal-hq/provider",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -17,7 +17,7 @@
     "prepare:esm": "tsc --outDir lib/esm --module es2015 --target es2015"
   },
   "dependencies": {
-    "@portal-hq/utils": "^0.2.11"
+    "@portal-hq/utils": "^0.2.12"
   },
   "devDependencies": {
     "typescript": "^4.8.4"