@luxexchange/api 1.0.0 → 1.0.1

package/src/clients/dataApi/getGetPortfolioQueryOptions.ts

@@ -1,10 +1,10 @@
 import { type PartialMessage } from '@bufbuild/protobuf'
 import { queryOptions } from '@tanstack/react-query'
 import type { GetPortfolioRequest, GetPortfolioResponse } from '@uniswap/client-data-api/dist/data/v1/api_pb'
-import { type DataApiServiceClient } from '@luxexchange/api/src/clients/dataApi/createDataApiServiceClient'
-import { transformInput, type WithoutWalletAccount } from '@luxexchange/api/src/connectRpc/utils'
-import { ReactQueryCacheKey } from '@luxfi/utilities/src/reactQuery/cache'
-import { type QueryOptionsResult } from '@luxfi/utilities/src/reactQuery/queryOptions'
+import { type DataApiServiceClient } from '@universe/api/src/clients/dataApi/createDataApiServiceClient'
+import { transformInput, type WithoutWalletAccount } from '@universe/api/src/connectRpc/utils'
+import { ReactQueryCacheKey } from 'utilities/src/reactQuery/cache'
+import { type QueryOptionsResult } from 'utilities/src/reactQuery/queryOptions'
 
 /**
  * Sorts `chainIds` in a query cache inputs object so that the same logical input
@@ -51,9 +51,13 @@ export function getGetPortfolioQueryOptions(
 ): QueryOptionsResult<GetPortfolioResponse | undefined, Error, GetPortfolioResponse | undefined, GetPortfolioQueryKey> {
   const transformedInput = transformInput(input)
 
-  const { modifier: _modifier, walletAccount: _walletAccount, ...queryCacheInputs } = transformedInput ?? {}
+  const { modifier, walletAccount: _walletAccount, ...queryCacheInputs } = transformedInput ?? {}
 
-  const queryCacheInputsSorted = sortQueryCacheInputs(queryCacheInputs)
+  const queryCacheInputsSorted = sortQueryCacheInputs({
+    ...queryCacheInputs,
+    includeSmallBalances: modifier?.includeSmallBalances,
+    includeSpamTokens: modifier?.includeSpamTokens,
+  })
 
   const addressKey = {
     ...(input?.evmAddress && { evmAddress: input.evmAddress }),

package/src/clients/embeddedWallet/createEmbeddedWalletApiClient.ts

@@ -1,47 +1,68 @@
 import { type PromiseClient } from '@connectrpc/connect'
 import { EmbeddedWalletService as OldEmbeddedWalletService } from '@uniswap/client-embeddedwallet/dist/uniswap/embeddedwallet/v1/service_connect'
 import {
-  type DeleteAuthenticatorResponse,
   type ExportSeedPhraseResponse,
-  type ListAuthenticatorsResponse,
   type Action as OldAction,
   type AuthenticationTypes as OldAuthenticationTypes,
-  type RegisterNewAuthenticatorResponse,
   type SecuredChallengeResponse,
 } from '@uniswap/client-embeddedwallet/dist/uniswap/embeddedwallet/v1/service_pb'
 import {
+  type AddAuthenticatorResponse,
   type ChallengeResponse,
   type CreateWalletResponse,
+  type DeleteAuthenticatorResponse,
+  type DeleteRecoveryResponse,
   type DisconnectResponse,
+  type ExecuteRecoveryResponse,
+  type GetRecoveryConfigResponse,
+  type ListAuthenticatorsResponse,
   type Action as NewAction,
   type AuthenticationTypes as NewAuthenticationTypes,
+  type OprfEvaluateResponse,
   type RegistrationOptions,
+  type ReportDecryptionResultResponse,
+  type SetupRecoveryResponse,
   type SignMessageResponse,
   type SignTransactionResponse,
   type SignTypedDataResponse,
+  type StartAuthenticatedSessionResponse,
   type WalletSignInResponse,
 } from '@uniswap/client-privy-embedded-wallet/dist/uniswap/privy-embedded-wallet/v1/service_pb'
 
 export type {
-  DeleteAuthenticatorResponse,
   ExportSeedPhraseResponse,
-  ListAuthenticatorsResponse,
-  RegisterNewAuthenticatorResponse,
   SecuredChallengeResponse,
 } from '@uniswap/client-embeddedwallet/dist/uniswap/embeddedwallet/v1/service_pb'
 export type {
   Action,
+  AddAuthenticatorResponse,
   AuthenticationTypes,
+  Authenticator,
   ChallengeResponse,
   CreateWalletResponse,
+  DeleteAuthenticatorResponse,
+  DeleteRecoveryResponse,
   DisconnectResponse,
+  ExecuteRecoveryResponse,
+  GetRecoveryConfigResponse,
+  ListAuthenticatorsResponse,
+  OprfEvaluateResponse,
+  RecoveryMethod,
   RegistrationOptions,
+  ReportDecryptionResultResponse,
+  SetupRecoveryResponse,
   SignMessageResponse,
   SignTransactionResponse,
   SignTypedDataResponse,
+  StartAuthenticatedSessionResponse,
   WalletSignInResponse,
 } from '@uniswap/client-privy-embedded-wallet/dist/uniswap/privy-embedded-wallet/v1/service_pb'
 
+export type SignAuth =
+  | { case: 'credential'; value: string }
+  | { case: 'deviceAuth'; value: { deviceSignature: string; walletId: string } }
+  | { case: undefined; value?: undefined }
+
 export interface EmbeddedWalletClientContext {
   rpcClient: {
     challenge: (req: Record<string, unknown>) => Promise<ChallengeResponse>
@@ -51,6 +72,16 @@ export interface EmbeddedWalletClientContext {
     signTransaction: (req: Record<string, unknown>) => Promise<SignTransactionResponse>
     signTypedData: (req: Record<string, unknown>) => Promise<SignTypedDataResponse>
     disconnect: (req: Record<string, unknown>) => Promise<DisconnectResponse>
+    listAuthenticators: (req: Record<string, unknown>) => Promise<ListAuthenticatorsResponse>
+    startAuthenticatedSession: (req: Record<string, unknown>) => Promise<StartAuthenticatedSessionResponse>
+    addAuthenticator: (req: Record<string, unknown>) => Promise<AddAuthenticatorResponse>
+    deleteAuthenticator: (req: Record<string, unknown>) => Promise<DeleteAuthenticatorResponse>
+    oprfEvaluate: (req: Record<string, unknown>) => Promise<OprfEvaluateResponse>
+    setupRecovery: (req: Record<string, unknown>) => Promise<SetupRecoveryResponse>
+    executeRecovery: (req: Record<string, unknown>) => Promise<ExecuteRecoveryResponse>
+    reportDecryptionResult: (req: Record<string, unknown>) => Promise<ReportDecryptionResultResponse>
+    getRecoveryConfig: (req: Record<string, unknown>) => Promise<GetRecoveryConfigResponse>
+    deleteRecovery: (req: Record<string, unknown>) => Promise<DeleteRecoveryResponse>
   }
   legacyRpcClient?: PromiseClient<typeof OldEmbeddedWalletService>
 }
@@ -64,30 +95,32 @@ export interface EmbeddedWalletApiClient {
     message?: string
     transaction?: string
     typedData?: string
+    authenticatorId?: string
+    devicePublicKey?: string
+    authPublicKey?: string
+    privyUserId?: string
   }) => Promise<ChallengeResponse>
 
-  fetchCreateWalletRequest: (params: { credential: string }) => Promise<CreateWalletResponse>
+  fetchCreateWalletRequest: (params: { credential: string; devicePublicKey: string }) => Promise<CreateWalletResponse>
 
   fetchWalletSigninRequest: (params: { credential: string }) => Promise<WalletSignInResponse>
 
-  // Batch operations adapted to single operations
-  fetchSignMessagesRequest: (params: {
-    messages: string[]
-    credential: string | undefined
-  }) => Promise<{ signatures: string[] }>
+  fetchSignMessagesRequest: (params: { messages: string[]; auth: SignAuth }) => Promise<{ signatures: string[] }>
 
   fetchSignTransactionsRequest: (params: {
     transactions: string[]
-    credential: string | undefined
+    auth: SignAuth
   }) => Promise<{ signatures: string[] }>
 
-  fetchSignTypedDataRequest: (params: {
-    typedDataBatch: string[]
-    credential: string | undefined
-  }) => Promise<{ signatures: string[] }>
+  fetchSignTypedDataRequest: (params: { typedDataBatch: string[]; auth: SignAuth }) => Promise<{ signatures: string[] }>
 
   fetchDisconnectRequest: () => Promise<DisconnectResponse>
 
+  fetchListAuthenticatorsRequest: (params: {
+    credential?: string
+    walletId?: string
+  }) => Promise<ListAuthenticatorsResponse>
+
   fetchSecuredChallengeRequest: (params: {
     type: OldAuthenticationTypes
     action: OldAction
@@ -99,27 +132,59 @@ export interface EmbeddedWalletApiClient {
     credential: string
   }) => Promise<ExportSeedPhraseResponse>
 
-  fetchListAuthenticatorsRequest: (params: { credential?: string }) => Promise<ListAuthenticatorsResponse>
+  fetchStartAuthenticatedSessionRequest: (params: {
+    existingCredential: string
+    devicePublicKey: string
+  }) => Promise<StartAuthenticatedSessionResponse>
 
-  fetchRegisterNewAuthenticatorRequest: (params: {
+  fetchAddAuthenticatorRequest: (params: {
     newCredential: string
-    newAuthenticationType: OldAuthenticationTypes
-    existingCredential: string
-    existingAuthenticationType: OldAuthenticationTypes
-  }) => Promise<RegisterNewAuthenticatorResponse>
+    deviceSignature: string
+  }) => Promise<AddAuthenticatorResponse>
 
   fetchDeleteAuthenticatorRequest: (params: {
     credential: string
-    authenticationType: OldAuthenticationTypes
     authenticatorId: string
-    authenticatorType: string
   }) => Promise<DeleteAuthenticatorResponse>
+
+  fetchOprfEvaluate: (params: {
+    blindedElement: string
+    isRecovery?: boolean
+    authMethodId?: string
+  }) => Promise<OprfEvaluateResponse>
+
+  fetchSetupRecovery: (params: {
+    credential: string
+    authMethodId: string
+    authMethodType?: string
+    encryptedKeyId?: string
+    authMethodIdentifier?: string
+  }) => Promise<SetupRecoveryResponse>
+
+  fetchExecuteRecovery: (params: {
+    authMethodId: string
+    newCredential: string
+    authKeySignature: string
+    recoveryAuthSignature: string
+  }) => Promise<ExecuteRecoveryResponse>
+
+  fetchReportDecryptionResult: (params: {
+    success: boolean
+    authMethodId: string
+    newPasskeyPublicKey?: string
+  }) => Promise<ReportDecryptionResultResponse>
+
+  fetchGetRecoveryConfig: (params: { authMethodId: string }) => Promise<GetRecoveryConfigResponse>
+
+  fetchDeleteRecovery: (params: { credential: string }) => Promise<DeleteRecoveryResponse>
 }
 
 export function createEmbeddedWalletApiClient({
   rpcClient,
   legacyRpcClient,
 }: EmbeddedWalletClientContext): EmbeddedWalletApiClient {
+  const inflightRequests = new Map<string, Promise<unknown>>()
+
   async function fetchChallengeRequest({
     type,
     action,
@@ -128,6 +193,10 @@ export function createEmbeddedWalletApiClient({
     message,
     transaction,
     typedData,
+    authenticatorId,
+    devicePublicKey,
+    authPublicKey,
+    privyUserId,
   }: {
     type: NewAuthenticationTypes
     action: NewAction
@@ -136,20 +205,49 @@ export function createEmbeddedWalletApiClient({
     message?: string
     transaction?: string
     typedData?: string
+    authenticatorId?: string
+    devicePublicKey?: string
+    authPublicKey?: string
+    privyUserId?: string
   }): Promise<ChallengeResponse> {
-    return await rpcClient.challenge({
-      type,
-      action,
-      options,
-      walletId,
-      message,
-      transaction,
-      typedData,
-    })
+    const cacheKey = `challenge:${type}:${action}:${walletId ?? 'no-wallet'}:${message ?? ''}:${transaction ?? ''}:${typedData ?? ''}:${authenticatorId ?? ''}:${devicePublicKey ?? ''}`
+
+    const existingRequest = inflightRequests.get(cacheKey) as Promise<ChallengeResponse> | undefined
+    if (existingRequest) {
+      return existingRequest
+    }
+
+    const request = rpcClient
+      .challenge({
+        type,
+        action,
+        options,
+        walletId,
+        message,
+        transaction,
+        typedData,
+        authenticatorId,
+        devicePublicKey,
+        authPublicKey,
+        privyUserId,
+      })
+      .finally(() => {
+        inflightRequests.delete(cacheKey)
+      })
+
+    inflightRequests.set(cacheKey, request)
+
+    return request
   }
 
-  async function fetchCreateWalletRequest({ credential }: { credential: string }): Promise<CreateWalletResponse> {
-    return await rpcClient.createWallet({ credential })
+  async function fetchCreateWalletRequest({
+    credential,
+    devicePublicKey,
+  }: {
+    credential: string
+    devicePublicKey: string
+  }): Promise<CreateWalletResponse> {
+    return await rpcClient.createWallet({ credential, devicePublicKey })
   }
 
   async function fetchWalletSigninRequest({ credential }: { credential: string }): Promise<WalletSignInResponse> {
@@ -158,10 +256,10 @@ export function createEmbeddedWalletApiClient({
 
   async function fetchSignMessagesRequest({
     messages,
-    credential,
+    auth,
   }: {
     messages: string[]
-    credential: string | undefined
+    auth: SignAuth
   }): Promise<{ signatures: string[] }> {
     if (messages.length === 0) {
       throw new Error('At least one message required')
@@ -171,17 +269,17 @@ export function createEmbeddedWalletApiClient({
     }
     const result = await rpcClient.signMessage({
       message: messages[0],
-      credential: credential ?? '',
+      auth,
     })
     return { signatures: [result.signature] }
   }
 
   async function fetchSignTransactionsRequest({
     transactions,
-    credential,
+    auth,
   }: {
     transactions: string[]
-    credential: string | undefined
+    auth: SignAuth
   }): Promise<{ signatures: string[] }> {
     if (transactions.length === 0) {
       throw new Error('At least one transaction required')
@@ -191,17 +289,17 @@ export function createEmbeddedWalletApiClient({
     }
     const result = await rpcClient.signTransaction({
       transaction: transactions[0],
-      credential: credential ?? '',
+      auth,
     })
     return { signatures: [result.signature] }
   }
 
   async function fetchSignTypedDataRequest({
     typedDataBatch,
-    credential,
+    auth,
   }: {
     typedDataBatch: string[]
-    credential: string | undefined
+    auth: SignAuth
   }): Promise<{ signatures: string[] }> {
     if (typedDataBatch.length === 0) {
       throw new Error('At least one typed data required')
@@ -211,7 +309,7 @@ export function createEmbeddedWalletApiClient({
     }
     const result = await rpcClient.signTypedData({
       typedData: typedDataBatch[0],
-      credential: credential ?? '',
+      auth,
     })
     return { signatures: [result.signature] }
   }
@@ -220,6 +318,29 @@ export function createEmbeddedWalletApiClient({
     return await rpcClient.disconnect({})
   }
 
+  async function fetchListAuthenticatorsRequest({
+    credential,
+    walletId,
+  }: {
+    credential?: string
+    walletId?: string
+  }): Promise<ListAuthenticatorsResponse> {
+    const cacheKey = `listAuthenticators:${credential ?? walletId ?? 'no-key'}`
+
+    const existingRequest = inflightRequests.get(cacheKey) as Promise<ListAuthenticatorsResponse> | undefined
+    if (existingRequest) {
+      return existingRequest
+    }
+
+    const request = rpcClient.listAuthenticators({ credential, walletId }).finally(() => {
+      inflightRequests.delete(cacheKey)
+    })
+
+    inflightRequests.set(cacheKey, request)
+
+    return request
+  }
+
   async function fetchSecuredChallengeRequest({
     type,
     action,
@@ -253,61 +374,105 @@ export function createEmbeddedWalletApiClient({
     return await legacyRpcClient.exportSeedPhrase({ credential, b64EncryptionPublicKey: encryptionKey })
   }
 
-  async function fetchListAuthenticatorsRequest({
-    credential,
+  async function fetchStartAuthenticatedSessionRequest({
+    existingCredential,
+    devicePublicKey,
   }: {
-    credential?: string
-  }): Promise<ListAuthenticatorsResponse> {
-    if (!legacyRpcClient) {
-      throw new Error('ListAuthenticators not supported in new API - legacy client required')
-    }
-    return await legacyRpcClient.listAuthenticators({ credential })
+    existingCredential: string
+    devicePublicKey: string
+  }): Promise<StartAuthenticatedSessionResponse> {
+    return await rpcClient.startAuthenticatedSession({ existingCredential, devicePublicKey })
   }
 
-  async function fetchRegisterNewAuthenticatorRequest({
+  async function fetchAddAuthenticatorRequest({
     newCredential,
-    newAuthenticationType,
-    existingCredential,
-    existingAuthenticationType,
+    deviceSignature,
   }: {
     newCredential: string
-    newAuthenticationType: OldAuthenticationTypes
-    existingCredential: string
-    existingAuthenticationType: OldAuthenticationTypes
-  }): Promise<RegisterNewAuthenticatorResponse> {
-    if (!legacyRpcClient) {
-      throw new Error('RegisterNewAuthenticator not supported in new API - legacy client required')
-    }
-    return await legacyRpcClient.registerNewAuthenticator({
-      newCredential,
-      newAuthenticationType,
-      existingCredential,
-      existingAuthenticationType,
-    })
+    deviceSignature: string
+  }): Promise<AddAuthenticatorResponse> {
+    return await rpcClient.addAuthenticator({ newCredential, deviceSignature })
   }
 
   async function fetchDeleteAuthenticatorRequest({
     credential,
-    authenticationType,
     authenticatorId,
-    authenticatorType,
   }: {
     credential: string
-    authenticationType: OldAuthenticationTypes
     authenticatorId: string
-    authenticatorType: string
   }): Promise<DeleteAuthenticatorResponse> {
-    if (!legacyRpcClient) {
-      throw new Error('DeleteAuthenticator not supported in new API - legacy client required')
-    }
-    return await legacyRpcClient.deleteAuthenticator({
+    return await rpcClient.deleteAuthenticator({ credential, authenticatorId })
+  }
+
+  async function fetchOprfEvaluate({
+    blindedElement,
+    isRecovery,
+    authMethodId,
+  }: {
+    blindedElement: string
+    isRecovery?: boolean
+    authMethodId?: string
+  }): Promise<OprfEvaluateResponse> {
+    return await rpcClient.oprfEvaluate({ blindedElement, isRecovery, authMethodId })
+  }
+
+  async function fetchSetupRecovery({
+    credential,
+    authMethodId,
+    authMethodType,
+    encryptedKeyId,
+    authMethodIdentifier,
+  }: {
+    credential: string
+    authMethodId: string
+    authMethodType?: string
+    encryptedKeyId?: string
+    authMethodIdentifier?: string
+  }): Promise<SetupRecoveryResponse> {
+    return await rpcClient.setupRecovery({
       credential,
-      type: authenticationType,
-      authenticatorId,
-      authenticatorType,
+      authMethodId,
+      authMethodType,
+      encryptedKeyId,
+      authMethodIdentifier,
     })
   }
 
+  async function fetchExecuteRecovery({
+    authMethodId,
+    newCredential,
+    authKeySignature,
+    recoveryAuthSignature,
+  }: {
+    authMethodId: string
+    newCredential: string
+    authKeySignature: string
+    recoveryAuthSignature: string
+  }): Promise<ExecuteRecoveryResponse> {
+    return await rpcClient.executeRecovery({
+      authMethodId,
+      newCredential,
+      authKeySignature,
+      recoveryAuthSignature,
+    })
+  }
+
+  async function fetchReportDecryptionResult(params: {
+    success: boolean
+    authMethodId: string
+    newPasskeyPublicKey?: string
+  }): Promise<ReportDecryptionResultResponse> {
+    return await rpcClient.reportDecryptionResult(params)
+  }
+
+  async function fetchGetRecoveryConfig(params: { authMethodId: string }): Promise<GetRecoveryConfigResponse> {
+    return await rpcClient.getRecoveryConfig(params)
+  }
+
+  async function fetchDeleteRecovery({ credential }: { credential: string }): Promise<DeleteRecoveryResponse> {
+    return await rpcClient.deleteRecovery({ credential })
+  }
+
   return {
     fetchChallengeRequest,
     fetchSecuredChallengeRequest,
@@ -319,7 +484,14 @@ export function createEmbeddedWalletApiClient({
     fetchExportSeedPhraseRequest,
     fetchDisconnectRequest,
     fetchListAuthenticatorsRequest,
-    fetchRegisterNewAuthenticatorRequest,
+    fetchStartAuthenticatedSessionRequest,
+    fetchAddAuthenticatorRequest,
     fetchDeleteAuthenticatorRequest,
+    fetchOprfEvaluate,
+    fetchSetupRecovery,
+    fetchExecuteRecovery,
+    fetchReportDecryptionResult,
+    fetchGetRecoveryConfig,
+    fetchDeleteRecovery,
   }
 }

package/src/clients/for/createForApiClient.ts

@@ -18,10 +18,10 @@ import {
   WidgetUrlRequest,
   WidgetUrlResponse,
 } from '@uniswap/client-for/dist/for/v1/api_pb'
-import { FetchClient } from '@luxexchange/api/src/clients/base/types'
-import { createFetcher } from '@luxexchange/api/src/clients/base/utils'
-import { FORQuoteResponse } from '@luxexchange/api/src/clients/for/types'
-import { transformPaymentMethods } from '@luxexchange/api/src/clients/for/utils'
+import { FetchClient } from '@universe/api/src/clients/base/types'
+import { createFetcher } from '@universe/api/src/clients/base/utils'
+import { FORQuoteResponse } from '@universe/api/src/clients/for/types'
+import { transformPaymentMethods } from '@universe/api/src/clients/for/utils'
 
 type ForApiClientContext = {
   fetchClient: FetchClient

package/src/clients/for/utils.ts

@@ -1,4 +1,4 @@
-import { isAndroid, isIOS } from '@luxfi/utilities/src/platform'
+import { isAndroid, isIOS } from 'utilities/src/platform'
 
 const APPLE_PAY = 'Apple Pay'
 const GOOGLE_PAY = 'Google Pay'

package/src/clients/gasService/createGasServiceClient.ts

@@ -0,0 +1,21 @@
+import { type PartialMessage } from '@bufbuild/protobuf'
+import { type PromiseClient } from '@connectrpc/connect'
+import { type UniRpcService } from '@uniswap/client-unirpc-v2/dist/uniswap/unirpc/v2/service_connect'
+import type {
+  EstimateGasFeeRequest,
+  EstimateGasFeeResponse,
+} from '@uniswap/client-unirpc-v2/dist/uniswap/unirpc/v2/service_pb'
+
+export interface GasServiceClientContext {
+  rpcClient: PromiseClient<typeof UniRpcService>
+}
+
+export interface GasServiceClient {
+  estimateGasFee: (params: PartialMessage<EstimateGasFeeRequest>) => Promise<EstimateGasFeeResponse>
+}
+
+export function createGasServiceClient({ rpcClient }: GasServiceClientContext): GasServiceClient {
+  return {
+    estimateGasFee: (params): Promise<EstimateGasFeeResponse> => rpcClient.estimateGasFee(params),
+  }
+}