@portal-hq/web 0.0.3 → 0.0.5

package/src/mpc/index.ts

@@ -3,14 +3,19 @@ import { PortalMpcError } from './errors'
 import Portal, { BackupMethods } from '../index'
 import type {
   BackupArgs,
+  Balance,
   ClientWithCustodianData,
   GenerateArgs,
+  GetTransactionsOrder,
   IframeConfigurationOptions,
   LegacyRecoverArgs,
   MpcOptions,
   MpcStatus,
+  NFT,
   PortalError,
   ProgressCallback,
+  QuoteArgs,
+  QuoteResponse,
   RecoverArgs,
   SignArgs,
   SimulateTransactionParam,
@@ -19,7 +24,7 @@ import type {
   WorkerResult,
 } from '../../types'
 
-const WEB_SDK_VERSION = '0.0.3'
+const WEB_SDK_VERSION = '0.0.5'
 
 class Mpc {
   public iframe?: HTMLIFrameElement
@@ -36,6 +41,10 @@ class Mpc {
     this.appendIframe()
   }
 
+  /*******************************
+   * Wallet Methods
+   *******************************/
+
   public async backup(
     data: BackupArgs,
     progress: ProgressCallback = () => {
@@ -402,11 +411,13 @@ class Mpc {
     })
   }
 
-  public storedClientBackupShare(success: boolean): Promise<void> {
+  /*******************************
+   * API Methods
+   *******************************/
+
+  public async getBalances(): Promise<Balance[]> {
     return new Promise((resolve, reject) => {
-      const handleStoredClientBackupShare = (
-        event: MessageEvent<WorkerResult>,
-      ) => {
+      const handleGetBalances = (event: MessageEvent<WorkerResult>) => {
         const { type, data } = event.data
         const { origin } = event
 
@@ -415,37 +426,35 @@ class Mpc {
           return
         }
 
-        if (type === 'portal:storedClientBackupShareError') {
+        if (type === 'portal:getBalancesError') {
           // Remove the event listener
-          window.removeEventListener('message', handleStoredClientBackupShare)
+          window.removeEventListener('message', handleGetBalances)
 
           // Reject the promise with the error
           return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:storedClientBackupShareResult') {
+        } else if (type === 'portal:getBalancesResult') {
           // Remove the event listener
-          window.removeEventListener('message', handleStoredClientBackupShare)
+          window.removeEventListener('message', handleGetBalances)
 
           // Resolve the promise with the result
-          resolve()
+          resolve(data as Balance[])
         }
       }
 
       // Bind the function to the message event
-      window.addEventListener('message', handleStoredClientBackupShare)
+      window.addEventListener('message', handleGetBalances)
 
       // Send the request to the iframe
       this.postMessage({
-        type: 'portal:storedClientBackupShare',
-        data: success,
+        type: 'portal:getBalances',
+        data: {},
       })
     })
   }
 
-  public async simulateTransaction(
-    transaction: SimulateTransactionParam,
-  ): Promise<SimulatedTransaction> {
+  public async getClient(): Promise<ClientWithCustodianData> {
     return new Promise((resolve, reject) => {
-      const handleSimulateTransaction = (event: MessageEvent<WorkerResult>) => {
+      const handleGetClient = (event: MessageEvent<WorkerResult>) => {
         const { type, data } = event.data
         const { origin } = event
 
@@ -454,33 +463,155 @@ class Mpc {
           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 as PortalError))
-        } 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 as SimulatedTransaction)
+          resolve(data as ClientWithCustodianData)
         }
       }
 
       // 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: {},
+      })
+    })
+  }
+
+  public async getNFTs(): Promise<NFT[]> {
+    return new Promise((resolve, reject) => {
+      const handleGetNFTs = (event: MessageEvent<WorkerResult>) => {
+        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 as PortalError))
+        } else if (type === 'portal:getNFTsResult') {
+          // Remove the event listener
+          window.removeEventListener('message', handleGetNFTs)
+
+          // Resolve the promise with the result
+          resolve(data as NFT[])
+        }
+      }
+
+      // Bind the function to the message event
+      window.addEventListener('message', handleGetNFTs)
+
+      // Send the request to the iframe
+      this.postMessage({
+        type: 'portal:getNFTs',
+        data: {},
       })
     })
   }
 
-  public async getTransactions(): Promise<Transaction[]> {
+  public async getQuote(
+    apiKey: string,
+    args: QuoteArgs,
+  ): Promise<QuoteResponse> {
+    return new Promise((resolve, reject) => {
+      const handleGetQuote = (event: MessageEvent<WorkerResult>) => {
+        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 as PortalError))
+        } else if (type === 'portal:swaps:getQuoteResult') {
+          // Remove the event listener
+          window.removeEventListener('message', handleGetQuote)
+
+          // Resolve the promise with the result
+          resolve(result as QuoteResponse)
+        }
+      }
+
+      // 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,
+        },
+      })
+    })
+  }
+
+  public async getSources(apiKey: string): Promise<Record<string, string>> {
+    return new Promise((resolve, reject) => {
+      const handleGetSources = (event: MessageEvent<WorkerResult>) => {
+        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 as PortalError))
+        } else if (type === 'portal:swaps:getSourcesResult') {
+          // Remove the event listener
+          window.removeEventListener('message', handleGetSources)
+
+          // Resolve the promise with the result
+          resolve(result as Record<string, string>)
+        }
+      }
+
+      // 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,
+        },
+      })
+    })
+  }
+
+  public async getTransactions(
+    limit?: number,
+    offset?: number,
+    order?: GetTransactionsOrder,
+    chainId?: number,
+  ): Promise<Transaction[]> {
     return new Promise((resolve, reject) => {
       const handleGetTransactions = (event: MessageEvent<WorkerResult>) => {
         const { type, data } = event.data
@@ -512,14 +643,21 @@ class Mpc {
       // Send the request to the iframe
       this.postMessage({
         type: 'portal:getTransactions',
-        data: {},
+        data: {
+          limit,
+          offset,
+          order,
+          chainId,
+        },
       })
     })
   }
 
-  public async getClient(): Promise<ClientWithCustodianData> {
+  public async simulateTransaction(
+    transaction: SimulateTransactionParam,
+  ): Promise<SimulatedTransaction> {
     return new Promise((resolve, reject) => {
-      const handleGetClient = (event: MessageEvent<WorkerResult>) => {
+      const handleSimulateTransaction = (event: MessageEvent<WorkerResult>) => {
         const { type, data } = event.data
         const { origin } = event
 
@@ -528,28 +666,67 @@ class Mpc {
           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 as PortalError))
-        } 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 as ClientWithCustodianData)
+          resolve(data as SimulatedTransaction)
         }
       }
 
       // 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,
+      })
+    })
+  }
+
+  public storedClientBackupShare(success: boolean): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const handleStoredClientBackupShare = (
+        event: MessageEvent<WorkerResult>,
+      ) => {
+        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 as PortalError))
+        } 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,
       })
     })
   }

package/types.d.ts

@@ -107,15 +107,16 @@ export interface DecryptArgs {
 }
 
 export interface DkgData {
-  share: string
-  ssid: string
-  pubkey: Pubkey
-  partialPubKey: Pubkey[]
   allY: Pubkey[]
+  bks: Bk[]
   p: string
-  q: string
+  partialPubKey: Pubkey[]
   pederson: PedersonParams[]
-  bks: Bk[]
+  pubkey: Pubkey
+  q: string
+  share: string
+  signingSharePairId?: string
+  ssid: string
 }
 
 export interface EIP1559Transaction {
@@ -328,6 +329,7 @@ export interface QuoteArgs {
 }
 
 export interface QuoteResponse {
+  allowanceTarget: string
   cost: string
   transaction: Eip1559 | LegacyTx
 }
@@ -427,14 +429,23 @@ export interface SimulatedTransaction {
   requestError?: SimulatedTransactionError
 }
 
+export enum GetTransactionsOrder {
+  ASC = 'asc',
+  DESC = 'desc',
+}
+
 export interface Transaction {
   asset: string
   blockNum: string
   category: string
+  chainId: number
   erc1155Metadata: null | string
   erc721TokenId: null | string
   from: string
   hash: string
+  metadata: {
+    blockTimestamp: string
+  }
   rawContract: {
     address: string
     decimal: string