@portal-hq/web 0.0.3 → 0.0.5

package/lib/esm/mpc/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { PortalMpcError } from './errors';
 import { BackupMethods } from '../index';
-const WEB_SDK_VERSION = '0.0.3';
+const WEB_SDK_VERSION = '0.0.5';
 class Mpc {
     constructor({ portal }) {
         this.configureIframe = () => {
@@ -37,6 +37,9 @@ class Mpc {
         // Create the iFrame for MPC operations
         this.appendIframe();
     }
+    /*******************************
+     * Wallet Methods
+     *******************************/
     backup(data, progress = () => {
         // Noop
     }) {
@@ -338,71 +341,180 @@ class Mpc {
             });
         });
     }
-    storedClientBackupShare(success) {
-        return new Promise((resolve, reject) => {
-            const handleStoredClientBackupShare = (event) => {
-                const { type, data } = event.data;
-                const { origin } = event;
-                // ignore any broadcast postMessages
-                if (origin !== this.getOrigin()) {
-                    return;
-                }
-                if (type === 'portal:storedClientBackupShareError') {
-                    // Remove the event listener
-                    window.removeEventListener('message', handleStoredClientBackupShare);
-                    // Reject the promise with the error
-                    return reject(new PortalMpcError(data));
-                }
-                else if (type === 'portal:storedClientBackupShareResult') {
-                    // Remove the event listener
-                    window.removeEventListener('message', handleStoredClientBackupShare);
-                    // Resolve the promise with the result
-                    resolve();
-                }
-            };
-            // Bind the function to the message event
-            window.addEventListener('message', handleStoredClientBackupShare);
-            // Send the request to the iframe
-            this.postMessage({
-                type: 'portal:storedClientBackupShare',
-                data: success,
+    /*******************************
+     * API Methods
+     *******************************/
+    getBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleGetBalances = (event) => {
+                    const { type, data } = event.data;
+                    const { origin } = event;
+                    // ignore any broadcast postMessages
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === 'portal:getBalancesError') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetBalances);
+                        // Reject the promise with the error
+                        return reject(new PortalMpcError(data));
+                    }
+                    else if (type === 'portal:getBalancesResult') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetBalances);
+                        // Resolve the promise with the result
+                        resolve(data);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleGetBalances);
+                // Send the request to the iframe
+                this.postMessage({
+                    type: 'portal:getBalances',
+                    data: {},
+                });
             });
         });
     }
-    simulateTransaction(transaction) {
+    getClient() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                const handleSimulateTransaction = (event) => {
+                const handleGetClient = (event) => {
                     const { type, data } = event.data;
                     const { origin } = event;
                     // ignore any broadcast postMessages
                     if (origin !== this.getOrigin()) {
                         return;
                     }
-                    if (type === 'portal:simulateTransactionError') {
+                    if (type === 'portal:getClientError') {
                         // Remove the event listener
-                        window.removeEventListener('message', handleSimulateTransaction);
+                        window.removeEventListener('message', handleGetClient);
                         // Reject the promise with the error
                         return reject(new PortalMpcError(data));
                     }
-                    else if (type === 'portal:simulateTransactionResult') {
+                    else if (type === 'portal:getClientResult') {
                         // Remove the event listener
-                        window.removeEventListener('message', handleSimulateTransaction);
+                        window.removeEventListener('message', handleGetClient);
                         // Resolve the promise with the result
                         resolve(data);
                     }
                 };
                 // Bind the function to the message event
-                window.addEventListener('message', handleSimulateTransaction);
+                window.addEventListener('message', handleGetClient);
                 // Send the request to the iframe
                 this.postMessage({
-                    type: 'portal:simulateTransaction',
-                    data: transaction,
+                    type: 'portal:getClient',
+                    data: {},
+                });
+            });
+        });
+    }
+    getNFTs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleGetNFTs = (event) => {
+                    const { type, data } = event.data;
+                    const { origin } = event;
+                    // ignore any broadcast postMessages
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === 'portal:getNFTsError') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetNFTs);
+                        // Reject the promise with the error
+                        return reject(new PortalMpcError(data));
+                    }
+                    else if (type === 'portal:getNFTsResult') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetNFTs);
+                        // Resolve the promise with the result
+                        resolve(data);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleGetNFTs);
+                // Send the request to the iframe
+                this.postMessage({
+                    type: 'portal:getNFTs',
+                    data: {},
                 });
             });
         });
     }
-    getTransactions() {
+    getQuote(apiKey, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleGetQuote = (event) => {
+                    const { type, data: result } = event.data;
+                    const { origin } = event;
+                    // ignore any broadcast postMessages
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === 'portal:swaps:getQuoteError') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetQuote);
+                        // Reject the promise with the error
+                        return reject(new PortalMpcError(result));
+                    }
+                    else if (type === 'portal:swaps:getQuoteResult') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetQuote);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleGetQuote);
+                // Send the request to the iframe
+                this.postMessage({
+                    type: 'portal:swaps:getQuote',
+                    data: {
+                        apiKey,
+                        args,
+                    },
+                });
+            });
+        });
+    }
+    getSources(apiKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleGetSources = (event) => {
+                    const { type, data: result } = event.data;
+                    const { origin } = event;
+                    // ignore any broadcast postMessages
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === 'portal:swaps:getSourcesError') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetSources);
+                        // Reject the promise with the error
+                        return reject(new PortalMpcError(result));
+                    }
+                    else if (type === 'portal:swaps:getSourcesResult') {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleGetSources);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleGetSources);
+                // Send the request to the iframe
+                this.postMessage({
+                    type: 'portal:swaps:getSources',
+                    data: {
+                        apiKey,
+                    },
+                });
+            });
+        });
+    }
+    getTransactions(limit, offset, order, chainId) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
                 const handleGetTransactions = (event) => {
@@ -430,44 +542,80 @@ class Mpc {
                 // Send the request to the iframe
                 this.postMessage({
                     type: 'portal:getTransactions',
-                    data: {},
+                    data: {
+                        limit,
+                        offset,
+                        order,
+                        chainId,
+                    },
                 });
             });
         });
     }
-    getClient() {
+    simulateTransaction(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                const handleGetClient = (event) => {
+                const handleSimulateTransaction = (event) => {
                     const { type, data } = event.data;
                     const { origin } = event;
                     // ignore any broadcast postMessages
                     if (origin !== this.getOrigin()) {
                         return;
                     }
-                    if (type === 'portal:getClientError') {
+                    if (type === 'portal:simulateTransactionError') {
                         // Remove the event listener
-                        window.removeEventListener('message', handleGetClient);
+                        window.removeEventListener('message', handleSimulateTransaction);
                         // Reject the promise with the error
                         return reject(new PortalMpcError(data));
                     }
-                    else if (type === 'portal:getClientResult') {
+                    else if (type === 'portal:simulateTransactionResult') {
                         // Remove the event listener
-                        window.removeEventListener('message', handleGetClient);
+                        window.removeEventListener('message', handleSimulateTransaction);
                         // Resolve the promise with the result
                         resolve(data);
                     }
                 };
                 // Bind the function to the message event
-                window.addEventListener('message', handleGetClient);
+                window.addEventListener('message', handleSimulateTransaction);
                 // Send the request to the iframe
                 this.postMessage({
-                    type: 'portal:getClient',
-                    data: {},
+                    type: 'portal:simulateTransaction',
+                    data: transaction,
                 });
             });
         });
     }
+    storedClientBackupShare(success) {
+        return new Promise((resolve, reject) => {
+            const handleStoredClientBackupShare = (event) => {
+                const { type, data } = event.data;
+                const { origin } = event;
+                // ignore any broadcast postMessages
+                if (origin !== this.getOrigin()) {
+                    return;
+                }
+                if (type === 'portal:storedClientBackupShareError') {
+                    // Remove the event listener
+                    window.removeEventListener('message', handleStoredClientBackupShare);
+                    // Reject the promise with the error
+                    return reject(new PortalMpcError(data));
+                }
+                else if (type === 'portal:storedClientBackupShareResult') {
+                    // Remove the event listener
+                    window.removeEventListener('message', handleStoredClientBackupShare);
+                    // Resolve the promise with the result
+                    resolve();
+                }
+            };
+            // Bind the function to the message event
+            window.addEventListener('message', handleStoredClientBackupShare);
+            // Send the request to the iframe
+            this.postMessage({
+                type: 'portal:storedClientBackupShare',
+                data: success,
+            });
+        });
+    }
     /***************************
      * Private Methods
      ***************************/

package/package.json

@@ -3,7 +3,7 @@
   "description": "Portal MPC Support for Web",
   "author": "Portal Labs, Inc.",
   "homepage": "https://portalhq.io/",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",

package/src/index.ts

@@ -1,12 +1,17 @@
 import type {
-  ClientWithCustodianData,
   BackupConfigs,
+  Balance,
+  ClientWithCustodianData,
   EthereumTransaction,
   FeatureFlags,
   GDriveConfig,
   GatewayLike,
+  GetTransactionsOrder,
+  NFT,
   PortalOptions,
   ProgressCallback,
+  QuoteArgs,
+  QuoteResponse,
   SimulateTransactionParam,
   SimulatedTransaction,
   Transaction,
@@ -46,7 +51,7 @@ class Portal {
     chainId = 1,
     gdrive,
     host = 'web.portalhq.io',
-    mpcVersion = 'v4',
+    mpcVersion = 'v5',
     featureFlags = {
       optimized: false,
     },
@@ -191,6 +196,10 @@ class Portal {
     return address
   }
 
+  /**
+   * @deprecated This method is deprecated and will be removed in a future version.
+   * Use the `recoverWallet` method instead.
+   */
   public async legacyRecoverWallet(
     cipherText: string,
     progress: ProgressCallback = () => {
@@ -212,6 +221,17 @@ class Portal {
     return recoveredCipherText
   }
 
+  public async provisionWallet(
+    cipherText: string,
+    backupMethod: BackupMethods,
+    backupConfigs: BackupConfigs,
+    progress: ProgressCallback = () => {
+      // Noop
+    },
+  ): Promise<string> {
+    return this.recoverWallet(cipherText, backupMethod, backupConfigs, progress)
+  }
+
   /****************************
    * Provider Methods
    ****************************/
@@ -272,18 +292,46 @@ class Portal {
    * API Methods
    *******************************/
 
+  public async getBalances(): Promise<Balance[]> {
+    return await this.mpc?.getBalances()
+  }
+
+  public async getClient(): Promise<ClientWithCustodianData> {
+    return this.mpc?.getClient()
+  }
+
+  public async getNFTs(): Promise<NFT[]> {
+    return this.mpc?.getNFTs()
+  }
+
+  public async getTransactions(
+    limit?: number,
+    offset?: number,
+    order?: GetTransactionsOrder,
+    chainId?: number,
+  ): Promise<Transaction[]> {
+    return this.mpc?.getTransactions(limit, offset, order, chainId)
+  }
+
   public async simulateTransaction(
     transaction: SimulateTransactionParam,
   ): Promise<SimulatedTransaction> {
     return this.mpc?.simulateTransaction(transaction)
   }
 
-  public async getTransactions(): Promise<Transaction[]> {
-    return this.mpc?.getTransactions()
+  /*******************************
+   * Swaps Methods
+   *******************************/
+
+  public async getQuote(
+    apiKey: string,
+    args: QuoteArgs,
+  ): Promise<QuoteResponse> {
+    return this.mpc?.getQuote(apiKey, args)
   }
 
-  public async getClient(): Promise<ClientWithCustodianData> {
-    return this.mpc?.getClient()
+  public async getSources(apiKey: string): Promise<Record<string, string>> {
+    return this.mpc?.getSources(apiKey)
   }
 
   /*******************************