@luxexchange/api 1.0.0

package/src/clients/embeddedWallet/createEmbeddedWalletApiClient.ts

@@ -0,0 +1,325 @@
+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 ChallengeResponse,
+  type CreateWalletResponse,
+  type DisconnectResponse,
+  type Action as NewAction,
+  type AuthenticationTypes as NewAuthenticationTypes,
+  type RegistrationOptions,
+  type SignMessageResponse,
+  type SignTransactionResponse,
+  type SignTypedDataResponse,
+  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,
+  AuthenticationTypes,
+  ChallengeResponse,
+  CreateWalletResponse,
+  DisconnectResponse,
+  RegistrationOptions,
+  SignMessageResponse,
+  SignTransactionResponse,
+  SignTypedDataResponse,
+  WalletSignInResponse,
+} from '@uniswap/client-privy-embedded-wallet/dist/uniswap/privy-embedded-wallet/v1/service_pb'
+
+export interface EmbeddedWalletClientContext {
+  rpcClient: {
+    challenge: (req: Record<string, unknown>) => Promise<ChallengeResponse>
+    createWallet: (req: Record<string, unknown>) => Promise<CreateWalletResponse>
+    walletSignIn: (req: Record<string, unknown>) => Promise<WalletSignInResponse>
+    signMessage: (req: Record<string, unknown>) => Promise<SignMessageResponse>
+    signTransaction: (req: Record<string, unknown>) => Promise<SignTransactionResponse>
+    signTypedData: (req: Record<string, unknown>) => Promise<SignTypedDataResponse>
+    disconnect: (req: Record<string, unknown>) => Promise<DisconnectResponse>
+  }
+  legacyRpcClient?: PromiseClient<typeof OldEmbeddedWalletService>
+}
+
+export interface EmbeddedWalletApiClient {
+  fetchChallengeRequest: (params: {
+    type: NewAuthenticationTypes
+    action: NewAction
+    options?: RegistrationOptions
+    walletId?: string
+    message?: string
+    transaction?: string
+    typedData?: string
+  }) => Promise<ChallengeResponse>
+
+  fetchCreateWalletRequest: (params: { credential: 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[] }>
+
+  fetchSignTransactionsRequest: (params: {
+    transactions: string[]
+    credential: string | undefined
+  }) => Promise<{ signatures: string[] }>
+
+  fetchSignTypedDataRequest: (params: {
+    typedDataBatch: string[]
+    credential: string | undefined
+  }) => Promise<{ signatures: string[] }>
+
+  fetchDisconnectRequest: () => Promise<DisconnectResponse>
+
+  fetchSecuredChallengeRequest: (params: {
+    type: OldAuthenticationTypes
+    action: OldAction
+    b64EncryptionPublicKey: string
+  }) => Promise<SecuredChallengeResponse>
+
+  fetchExportSeedPhraseRequest: (params: {
+    encryptionKey: string
+    credential: string
+  }) => Promise<ExportSeedPhraseResponse>
+
+  fetchListAuthenticatorsRequest: (params: { credential?: string }) => Promise<ListAuthenticatorsResponse>
+
+  fetchRegisterNewAuthenticatorRequest: (params: {
+    newCredential: string
+    newAuthenticationType: OldAuthenticationTypes
+    existingCredential: string
+    existingAuthenticationType: OldAuthenticationTypes
+  }) => Promise<RegisterNewAuthenticatorResponse>
+
+  fetchDeleteAuthenticatorRequest: (params: {
+    credential: string
+    authenticationType: OldAuthenticationTypes
+    authenticatorId: string
+    authenticatorType: string
+  }) => Promise<DeleteAuthenticatorResponse>
+}
+
+export function createEmbeddedWalletApiClient({
+  rpcClient,
+  legacyRpcClient,
+}: EmbeddedWalletClientContext): EmbeddedWalletApiClient {
+  async function fetchChallengeRequest({
+    type,
+    action,
+    options,
+    walletId,
+    message,
+    transaction,
+    typedData,
+  }: {
+    type: NewAuthenticationTypes
+    action: NewAction
+    options?: RegistrationOptions
+    walletId?: string
+    message?: string
+    transaction?: string
+    typedData?: string
+  }): Promise<ChallengeResponse> {
+    return await rpcClient.challenge({
+      type,
+      action,
+      options,
+      walletId,
+      message,
+      transaction,
+      typedData,
+    })
+  }
+
+  async function fetchCreateWalletRequest({ credential }: { credential: string }): Promise<CreateWalletResponse> {
+    return await rpcClient.createWallet({ credential })
+  }
+
+  async function fetchWalletSigninRequest({ credential }: { credential: string }): Promise<WalletSignInResponse> {
+    return await rpcClient.walletSignIn({ credential })
+  }
+
+  async function fetchSignMessagesRequest({
+    messages,
+    credential,
+  }: {
+    messages: string[]
+    credential: string | undefined
+  }): Promise<{ signatures: string[] }> {
+    if (messages.length === 0) {
+      throw new Error('At least one message required')
+    }
+    if (messages.length > 1) {
+      throw new Error('Batch message signing not yet supported - use single message')
+    }
+    const result = await rpcClient.signMessage({
+      message: messages[0],
+      credential: credential ?? '',
+    })
+    return { signatures: [result.signature] }
+  }
+
+  async function fetchSignTransactionsRequest({
+    transactions,
+    credential,
+  }: {
+    transactions: string[]
+    credential: string | undefined
+  }): Promise<{ signatures: string[] }> {
+    if (transactions.length === 0) {
+      throw new Error('At least one transaction required')
+    }
+    if (transactions.length > 1) {
+      throw new Error('Batch transaction signing not yet supported - use single transaction')
+    }
+    const result = await rpcClient.signTransaction({
+      transaction: transactions[0],
+      credential: credential ?? '',
+    })
+    return { signatures: [result.signature] }
+  }
+
+  async function fetchSignTypedDataRequest({
+    typedDataBatch,
+    credential,
+  }: {
+    typedDataBatch: string[]
+    credential: string | undefined
+  }): Promise<{ signatures: string[] }> {
+    if (typedDataBatch.length === 0) {
+      throw new Error('At least one typed data required')
+    }
+    if (typedDataBatch.length > 1) {
+      throw new Error('Batch typed data signing not yet supported - use single typed data')
+    }
+    const result = await rpcClient.signTypedData({
+      typedData: typedDataBatch[0],
+      credential: credential ?? '',
+    })
+    return { signatures: [result.signature] }
+  }
+
+  async function fetchDisconnectRequest(): Promise<DisconnectResponse> {
+    return await rpcClient.disconnect({})
+  }
+
+  async function fetchSecuredChallengeRequest({
+    type,
+    action,
+    b64EncryptionPublicKey,
+  }: {
+    type: OldAuthenticationTypes
+    action: OldAction
+    b64EncryptionPublicKey: string
+    walletId?: string
+  }): Promise<SecuredChallengeResponse> {
+    if (!legacyRpcClient) {
+      throw new Error('SecuredChallenge not supported in new API - legacy client required')
+    }
+    return await legacyRpcClient.securedChallenge({
+      type,
+      action,
+      b64EncryptionPublicKey,
+    })
+  }
+
+  async function fetchExportSeedPhraseRequest({
+    encryptionKey,
+    credential,
+  }: {
+    encryptionKey: string
+    credential: string
+  }): Promise<ExportSeedPhraseResponse> {
+    if (!legacyRpcClient) {
+      throw new Error('ExportSeedPhrase not supported in new API - legacy client required')
+    }
+    return await legacyRpcClient.exportSeedPhrase({ credential, b64EncryptionPublicKey: encryptionKey })
+  }
+
+  async function fetchListAuthenticatorsRequest({
+    credential,
+  }: {
+    credential?: string
+  }): Promise<ListAuthenticatorsResponse> {
+    if (!legacyRpcClient) {
+      throw new Error('ListAuthenticators not supported in new API - legacy client required')
+    }
+    return await legacyRpcClient.listAuthenticators({ credential })
+  }
+
+  async function fetchRegisterNewAuthenticatorRequest({
+    newCredential,
+    newAuthenticationType,
+    existingCredential,
+    existingAuthenticationType,
+  }: {
+    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,
+    })
+  }
+
+  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({
+      credential,
+      type: authenticationType,
+      authenticatorId,
+      authenticatorType,
+    })
+  }
+
+  return {
+    fetchChallengeRequest,
+    fetchSecuredChallengeRequest,
+    fetchCreateWalletRequest,
+    fetchWalletSigninRequest,
+    fetchSignMessagesRequest,
+    fetchSignTransactionsRequest,
+    fetchSignTypedDataRequest,
+    fetchExportSeedPhraseRequest,
+    fetchDisconnectRequest,
+    fetchListAuthenticatorsRequest,
+    fetchRegisterNewAuthenticatorRequest,
+    fetchDeleteAuthenticatorRequest,
+  }
+}

package/src/clients/for/createForApiClient.ts

@@ -0,0 +1,187 @@
+import { PlainMessage } from '@bufbuild/protobuf'
+import {
+  GetCountryResponse,
+  OffRampTransferDetailsRequest,
+  OffRampTransferDetailsResponse,
+  OffRampWidgetUrlRequest,
+  QuoteRequest,
+  SupportedCountriesRequest,
+  SupportedCountriesResponse,
+  SupportedFiatCurrenciesRequest,
+  SupportedFiatCurrenciesResponse,
+  SupportedTokensRequest,
+  SupportedTokensResponse,
+  TransactionRequest,
+  TransactionResponse,
+  TransferServiceProvidersResponse,
+  TransferWidgetUrlRequest,
+  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'
+
+type ForApiClientContext = {
+  fetchClient: FetchClient
+}
+
+export type ForApiClient = {
+  getSupportedCountries: (request: PlainMessage<SupportedCountriesRequest>) => Promise<SupportedCountriesResponse>
+  getCountry: () => Promise<GetCountryResponse>
+  getCryptoQuote: (request: PlainMessage<QuoteRequest>) => Promise<FORQuoteResponse>
+  getTransferServiceProviders: () => Promise<TransferServiceProvidersResponse>
+  getSupportedTokens: (request: PlainMessage<SupportedTokensRequest>) => Promise<SupportedTokensResponse>
+  getSupportedFiatCurrencies: (
+    request: PlainMessage<SupportedFiatCurrenciesRequest>,
+  ) => Promise<SupportedFiatCurrenciesResponse>
+  getWidgetUrl: (request: PlainMessage<WidgetUrlRequest>) => Promise<WidgetUrlResponse>
+  getTransferWidgetUrl: (request: PlainMessage<TransferWidgetUrlRequest>) => Promise<WidgetUrlResponse>
+  getTransaction: (request: PlainMessage<TransactionRequest> & { sessionId: string }) => Promise<TransactionResponse>
+  getOffRampWidgetUrl: (request: PlainMessage<OffRampWidgetUrlRequest>) => Promise<WidgetUrlResponse>
+  getOffRampTransferDetails: (
+    request: PlainMessage<OffRampTransferDetailsRequest>,
+  ) => Promise<OffRampTransferDetailsResponse>
+}
+
+/**
+ * Factory function to create a FOR (Fiat On-Ramp) API client
+ *
+ * @example
+ * ```typescript
+ * const forClient = createForApiClient({
+ *   fetchClient: myFetchClient,
+ * })
+ *
+ * const quote = await forClient.getCryptoQuote({
+ *   countryCode: 'US',
+ *   sourceCurrencyCode: 'USD',
+ *   destinationCurrencyCode: 'ETH',
+ *   sourceAmount: 100,
+ * })
+ * ```
+ *
+ * @param ctx - Context containing the FetchClient instance
+ * @returns ForApiClient instance with all FOR API methods
+ */
+export function createForApiClient(ctx: ForApiClientContext): ForApiClient {
+  const client = ctx.fetchClient
+
+  // POST /SupportedCountries
+  const getSupportedCountries = createFetcher<PlainMessage<SupportedCountriesRequest>, SupportedCountriesResponse>({
+    client,
+    method: 'post',
+    url: '/SupportedCountries',
+  })
+
+  // POST /GetCountry
+  const getCountryFetcher = createFetcher<Record<string, never>, GetCountryResponse>({
+    client,
+    method: 'post',
+    url: '/GetCountry',
+  })
+  const getCountry = (): Promise<GetCountryResponse> => getCountryFetcher({})
+
+  // POST /Quote - with response transformation for payment methods
+  const getCryptoQuoteRaw = createFetcher<PlainMessage<QuoteRequest>, FORQuoteResponse>({
+    client,
+    method: 'post',
+    url: '/Quote',
+  })
+
+  const getCryptoQuote = async (request: PlainMessage<QuoteRequest>): Promise<FORQuoteResponse> => {
+    const response = await getCryptoQuoteRaw(request)
+    // Apply payment method transformation (filters Apple Pay on Android, Google Pay on iOS)
+    return {
+      ...response,
+      quotes: response.quotes.map((quote) => ({
+        ...quote,
+        serviceProviderDetails: quote.serviceProviderDetails
+          ? {
+              ...quote.serviceProviderDetails,
+              paymentMethods: transformPaymentMethods(quote.serviceProviderDetails.paymentMethods),
+            }
+          : undefined,
+      })),
+    }
+  }
+
+  // POST /TransferServiceProviders
+  const getTransferServiceProvidersFetcher = createFetcher<Record<string, never>, TransferServiceProvidersResponse>({
+    client,
+    method: 'post',
+    url: '/TransferServiceProviders',
+  })
+  const getTransferServiceProviders = (): Promise<TransferServiceProvidersResponse> =>
+    getTransferServiceProvidersFetcher({})
+
+  // POST /SupportedTokens
+  const getSupportedTokens = createFetcher<PlainMessage<SupportedTokensRequest>, SupportedTokensResponse>({
+    client,
+    method: 'post',
+    url: '/SupportedTokens',
+  })
+
+  // POST /SupportedFiatCurrencies
+  const getSupportedFiatCurrencies = createFetcher<
+    PlainMessage<SupportedFiatCurrenciesRequest>,
+    SupportedFiatCurrenciesResponse
+  >({
+    client,
+    method: 'post',
+    url: '/SupportedFiatCurrencies',
+  })
+
+  // POST /WidgetUrl
+  const getWidgetUrl = createFetcher<PlainMessage<WidgetUrlRequest>, WidgetUrlResponse>({
+    client,
+    method: 'post',
+    url: '/WidgetUrl',
+  })
+
+  // POST /TransferWidgetUrl
+  const getTransferWidgetUrl = createFetcher<PlainMessage<TransferWidgetUrlRequest>, WidgetUrlResponse>({
+    client,
+    method: 'post',
+    url: '/TransferWidgetUrl',
+  })
+
+  // POST /Transaction
+  const getTransaction = createFetcher<PlainMessage<TransactionRequest> & { sessionId: string }, TransactionResponse>({
+    client,
+    method: 'post',
+    url: '/Transaction',
+  })
+
+  // POST /OffRampWidgetUrl
+  const getOffRampWidgetUrl = createFetcher<PlainMessage<OffRampWidgetUrlRequest>, WidgetUrlResponse>({
+    client,
+    method: 'post',
+    url: '/OffRampWidgetUrl',
+  })
+
+  // POST /OffRampTransferDetails
+  const getOffRampTransferDetails = createFetcher<
+    PlainMessage<OffRampTransferDetailsRequest>,
+    OffRampTransferDetailsResponse
+  >({
+    client,
+    method: 'post',
+    url: '/OffRampTransferDetails',
+  })
+
+  return {
+    getSupportedCountries,
+    getCountry,
+    getCryptoQuote,
+    getTransferServiceProviders,
+    getSupportedTokens,
+    getSupportedFiatCurrencies,
+    getWidgetUrl,
+    getTransferWidgetUrl,
+    getTransaction,
+    getOffRampWidgetUrl,
+    getOffRampTransferDetails,
+  }
+}

package/src/clients/for/types.ts

@@ -0,0 +1,39 @@
+/**
+ * FOR (Fiat On-Ramp) API Client Types
+ *
+ * This file creates PlainMessage type aliases for protobuf types.
+ * PlainMessage converts protobuf classes to plain object types for REST API usage.
+ */
+
+import { PlainMessage } from '@bufbuild/protobuf'
+import {
+  FiatCurrency,
+  Quote,
+  QuoteResponse,
+  ServiceProvider,
+  ServiceProviderLogo,
+  SupportedCountry,
+  SupportedToken,
+  Transaction,
+} from '@uniswap/client-for/dist/for/v1/api_pb'
+
+// Plain object type aliases for protobuf types
+
+export type FORCountry = PlainMessage<SupportedCountry> & {
+  /** State code for US addresses (app-specific extension) */
+  state?: string
+}
+
+export type FORQuote = PlainMessage<Quote>
+
+export type FORQuoteResponse = PlainMessage<QuoteResponse>
+
+export type FORLogo = PlainMessage<ServiceProviderLogo>
+
+export type FORServiceProvider = PlainMessage<ServiceProvider>
+
+export type FORSupportedToken = PlainMessage<SupportedToken>
+
+export type FORSupportedFiatCurrency = PlainMessage<FiatCurrency>
+
+export type FORTransaction = PlainMessage<Transaction>

package/src/clients/for/utils.ts

@@ -0,0 +1,13 @@
+import { isAndroid, isIOS } from '@luxfi/utilities/src/platform'
+
+const APPLE_PAY = 'Apple Pay'
+const GOOGLE_PAY = 'Google Pay'
+
+/**
+ * Filters payment methods based on the current platform.
+ * - Removes Apple Pay on Android devices
+ * - Removes Google Pay on iOS devices
+ */
+export function transformPaymentMethods(paymentMethods: string[]): string[] {
+  return paymentMethods.filter((pm) => !(pm === APPLE_PAY && isAndroid) && !(pm === GOOGLE_PAY && isIOS))
+}