Add core-side synthetic destination for swap-to-address

- EdgeSwapRequest accepts an optional toAddressInfo descriptor
  (toPluginId, toAddress, toMemos) as an alternative to toWallet, with
  exactly one of the two required. The core builds a synthetic,
  bridgified destination wallet backed by the real currencyConfig, so
  swap plugins receive an EdgeCurrencyWallet unchanged.
- Destination memos (e.g. an XRP destination tag) use the descriptor
  only as GUI-to-core transport; plugins read them off the synthetic
  wallet's getMemos method (EdgeSyntheticDestinationWallet).
- EdgeTxActionSwap.payoutWalletId and EdgeTxSwap.payoutWalletId become
  optional, since a swap-to-address destination has no payout wallet.
- The pasted destination address and memo values are redacted from
  swap-quote logs.

Author: j0ntz

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+- added: Accept an optional `toAddressInfo` descriptor on `EdgeSwapRequest` as an alternative to `toWallet`, so a swap can target a pasted destination address. The core builds a synthetic, bridgified destination wallet from the descriptor, backed by the real `currencyConfig`, leaving swap plugins unchanged. Exactly one of `toWallet` or `toAddressInfo` is required.
+- added: Optional `toMemos` on `EdgeSwapToAddressInfo` for memo-required payout chains (e.g. an XRP destination tag). Swap plugins read the memos off the synthetic destination wallet's `getMemos` method (`EdgeSyntheticDestinationWallet`), never off the descriptor.
+- changed: Make `EdgeTxActionSwap.payoutWalletId` and `EdgeTxSwap.payoutWalletId` optional, since a swap-to-address destination has no payout wallet (`payoutAddress` carries the destination).
+
 ## 2.46.1 (2026-06-29)
 
 - changed: Upgrade yaob to v0.4.0 to share a single bridge instance with currency plugins (mismatched yaob copies give the bridge separate object-id counters that cross-wire bridged nativeIo objects).

src/core/currency/wallet/currency-wallet-cleaners.ts

@@ -146,7 +146,7 @@ export const asEdgeTxSwap = asObject<EdgeTxSwap>({
   payoutCurrencyCode: asString,
   payoutTokenId: asOptional(asEdgeTokenId),
   payoutNativeAmount: asString,
-  payoutWalletId: asString,
+  payoutWalletId: asOptional(asString),
   refundAddress: asOptional(asString)
 })
 
@@ -190,7 +190,7 @@ export const asEdgeTxActionSwap = asObject<EdgeTxActionSwap>({
   canBePartial: asOptional(asBoolean),
   fromAsset: asEdgeAssetAmount,
   toAsset: asEdgeAssetAmount,
-  payoutWalletId: asString,
+  payoutWalletId: asOptional(asString),
   payoutAddress: asString,
   refundAddress: asOptional(asString)
 })

src/core/swap/swap-api.ts

@@ -14,10 +14,13 @@ import {
   EdgeSwapPlugin,
   EdgeSwapQuote,
   EdgeSwapRequest,
-  EdgeSwapRequestOptions
+  EdgeSwapRequestOptions,
+  EdgeSwapToAddressInfo
 } from '../../types/types'
 import { fuzzyTimeout, timeout } from '../../util/promise'
+import { CurrencyConfig } from '../account/plugin-api'
 import { ApiInput } from '../root-pixie'
+import { makeSyntheticDestinationWallet } from './synthetic-wallet'
 
 /**
  * Fetch quotes from all plugins, and sorts the best ones to the front.
@@ -41,12 +44,24 @@ export async function fetchSwapQuotes(
   const { swapSettings, userSettings } = account
   const swapPlugins = state.plugins.swap
 
+  // Resolve the destination. A normal swap provides `toWallet`; a
+  // swap-to-address (private send) request provides `toAddressInfo` instead, and
+  // the core builds a synthetic destination wallet from it so plugins receive an
+  // `EdgeCurrencyWallet` unchanged.
+  const swapRequest = resolveSwapRequest(ai, accountId, request)
+
   log.warn(
     'Requesting swap quotes for: ',
     {
-      ...request,
-      fromWallet: request.fromWallet.id,
-      toWallet: request.toWallet.id
+      ...swapRequest,
+      fromWallet: swapRequest.fromWallet.id,
+      toWallet: swapRequest.toWallet?.id,
+      // Never log the pasted destination address or its memos
+      // (private-send privacy):
+      toAddressInfo:
+        swapRequest.toAddressInfo == null
+          ? undefined
+          : redactToAddressInfo(swapRequest.toAddressInfo)
     },
     { preferPluginId, promoCodes }
   )
@@ -63,14 +78,24 @@ export async function fetchSwapQuotes(
     pendingIds.add(pluginId)
     promises.push(
       swapPlugins[pluginId]
-        .fetchSwapQuote(request, userSettings[pluginId], {
+        .fetchSwapQuote(swapRequest, userSettings[pluginId], {
           infoPayload: state.infoCache.corePlugins?.[pluginId] ?? {},
           promoCode: promoCodes[pluginId]
         })
         .then(
           quote => {
             upgradeSwapQuote(quote)
-            const { fromWallet, toWallet, ...request } = quote.request ?? {}
+            const { fromWallet, toWallet, toAddressInfo, ...rest } =
+              quote.request ?? {}
+            // Never log the pasted destination address or its memos
+            // (private-send privacy):
+            const request =
+              toAddressInfo == null
+                ? rest
+                : {
+                    ...rest,
+                    toAddressInfo: redactToAddressInfo(toAddressInfo)
+                  }
             const cleaned = { ...quote, request }
             pendingIds.delete(pluginId)
             log.warn(`${pluginId} gave swap quote:`, cleaned)
@@ -86,12 +111,12 @@ export async function fetchSwapQuotes(
                 swapPluginId: pluginId,
                 request: {
                   // Stringify to include "null"
-                  fromToken: String(request.fromTokenId),
-                  fromWalletType: request.fromWallet.type,
+                  fromToken: String(swapRequest.fromTokenId),
+                  fromWalletType: swapRequest.fromWallet.type,
                   // Stringify to include "null"
-                  toToken: String(request.toTokenId),
-                  toWalletType: request.toWallet.type,
-                  quoteFor: request.quoteFor
+                  toToken: String(swapRequest.toTokenId),
+                  toWalletType: swapRequest.toWallet?.type,
+                  quoteFor: swapRequest.quoteFor
                 }
               })
             }
@@ -117,7 +142,7 @@ export async function fetchSwapQuotes(
       )
 
       // Prepare quotes for the bridge:
-      return quotes.map(quote => wrapQuote(swapPlugins, request, quote))
+      return quotes.map(quote => wrapQuote(swapPlugins, swapRequest, quote))
     },
     (errors: unknown[]) => {
       log.warn(`All ${promises.length} swap quotes rejected.`)
@@ -129,6 +154,64 @@ export async function fetchSwapQuotes(
   return await timeout(promise, noResponseMs)
 }
 
+/**
+ * Strips the private pieces (destination address and memos) out of a
+ * `toAddressInfo` descriptor so it can be logged.
+ */
+function redactToAddressInfo(
+  toAddressInfo: EdgeSwapToAddressInfo
+): EdgeSwapToAddressInfo {
+  const { toMemos } = toAddressInfo
+  return {
+    ...toAddressInfo,
+    toAddress: '[redacted]',
+    toMemos:
+      toMemos == null
+        ? undefined
+        : toMemos.map(memo => ({ ...memo, value: '[redacted]' }))
+  }
+}
+
+/**
+ * Validates the destination on a swap request and resolves it to a request that
+ * always carries a `toWallet`. Exactly one of `toWallet` or `toAddressInfo` must
+ * be present; when it is `toAddressInfo`, a synthetic destination wallet is built
+ * core-side from the descriptor.
+ */
+function resolveSwapRequest(
+  ai: ApiInput,
+  accountId: string,
+  request: EdgeSwapRequest
+): EdgeSwapRequest {
+  const { toWallet, toAddressInfo } = request
+
+  if ((toWallet == null) === (toAddressInfo == null)) {
+    throw new Error(
+      'Swap request must include exactly one of `toWallet` or `toAddressInfo`'
+    )
+  }
+  if (toAddressInfo == null) return request
+
+  const { toPluginId, toAddress, toMemos } = toAddressInfo
+  const { toTokenId } = request
+  if (ai.props.state.plugins.currency[toPluginId] == null) {
+    throw new Error(
+      `Cannot build swap destination: no currency plugin "${toPluginId}"`
+    )
+  }
+  const currencyConfig = new CurrencyConfig(ai, accountId, toPluginId)
+  if (toTokenId != null && currencyConfig.allTokens[toTokenId] == null) {
+    throw new Error(
+      `Cannot build swap destination: no token "${toTokenId}" on plugin "${toPluginId}"`
+    )
+  }
+
+  return {
+    ...request,
+    toWallet: makeSyntheticDestinationWallet(currencyConfig, toAddress, toMemos)
+  }
+}
+
 function wrapQuote(
   swapPlugins: EdgePluginMap<EdgeSwapPlugin>,
   request: EdgeSwapRequest,

src/core/swap/synthetic-wallet.ts

@@ -0,0 +1,76 @@
+import { bridgifyObject } from 'yaob'
+
+import {
+  EdgeAddress,
+  EdgeCurrencyConfig,
+  EdgeCurrencyWallet,
+  EdgeMemo,
+  EdgeReceiveAddress
+} from '../../types/types'
+
+/**
+ * A prefix marking a synthetic destination wallet's `id`. A swap-to-address
+ * destination has no real payout wallet, so this id does not resolve to one;
+ * it only exists because plugins read `toWallet.id` for order metadata.
+ */
+export const SYNTHETIC_WALLET_ID_PREFIX = 'synthetic://'
+
+/**
+ * Build a synthetic, bridgified destination wallet for a swap-to-address
+ * request. It is backed by the real `currencyConfig` core already holds, so
+ * `currencyInfo` and `currencyConfig.allTokens` are authentic, while
+ * `getAddresses` / `getReceiveAddress` return the pasted destination address.
+ *
+ * It is bridgified here (core-side) so swap-plugin method calls work unchanged
+ * and so it survives the yaob wire format when it rides back to the GUI inside
+ * `quote.request.toWallet`. A GUI-built fake cannot do this: its function
+ * properties fail to cross the bridge (see the Phase 1 verdict).
+ */
+export function makeSyntheticDestinationWallet(
+  currencyConfig: EdgeCurrencyConfig,
+  toAddress: string,
+  toMemos: EdgeMemo[] = []
+): EdgeCurrencyWallet {
+  const { currencyInfo } = currencyConfig
+
+  const addresses: EdgeAddress[] = [
+    { addressType: 'publicAddress', publicAddress: toAddress }
+  ]
+  const receiveAddress: EdgeReceiveAddress = {
+    publicAddress: toAddress,
+    metadata: {},
+    nativeAmount: '0'
+  }
+
+  const wallet = {
+    id: `${SYNTHETIC_WALLET_ID_PREFIX}${currencyInfo.pluginId}`,
+    type: currencyInfo.walletType,
+    currencyConfig,
+    currencyInfo,
+
+    async getAddresses(): Promise<EdgeAddress[]> {
+      return addresses
+    },
+
+    /**
+     * Destination memos (e.g. an XRP destination tag) for the payout.
+     * Not part of `EdgeCurrencyWallet` — see `EdgeSyntheticDestinationWallet`.
+     * Plugins that support destination memos detect this method at runtime.
+     */
+    async getMemos(): Promise<EdgeMemo[]> {
+      return toMemos
+    },
+
+    async getReceiveAddress(): Promise<EdgeReceiveAddress> {
+      return receiveAddress
+    }
+  }
+  bridgifyObject(wallet)
+
+  // The synthetic destination only implements the `EdgeCurrencyWallet` surface
+  // that swap plugins read on `toWallet` (id, type, currencyInfo,
+  // currencyConfig, getAddresses, getReceiveAddress), plus the synthetic-only
+  // `getMemos` (see `EdgeSyntheticDestinationWallet`). It is never used as a
+  // source wallet, so the spend/sign/sync methods are intentionally absent.
+  return wallet as unknown as EdgeCurrencyWallet
+}

src/types/error.ts

@@ -309,9 +309,13 @@ export class SwapCurrencyError extends Error {
   readonly toTokenId: EdgeTokenId
 
   constructor(swapInfo: EdgeSwapInfo, request: EdgeSwapRequest) {
-    const { fromWallet, toWallet, fromTokenId, toTokenId } = request
+    const { fromWallet, toWallet, toAddressInfo, fromTokenId, toTokenId } =
+      request
     const fromPluginId = fromWallet.currencyConfig.currencyInfo.pluginId
-    const toPluginId = toWallet.currencyConfig.currencyInfo.pluginId
+    const toPluginId =
+      toWallet?.currencyConfig.currencyInfo.pluginId ??
+      toAddressInfo?.toPluginId ??
+      ''
 
     const fromString = `${fromPluginId}:${String(fromTokenId)}`
     const toString = `${toPluginId}:${String(toTokenId)}`

src/types/types.ts

@@ -284,7 +284,16 @@ export interface EdgeTxActionSwap {
   fromAsset: EdgeAssetAmount
   toAsset: EdgeAssetAmount
   payoutAddress: string
-  payoutWalletId: string
+
+  /**
+   * The wallet that received the payout, for a normal wallet-to-wallet swap.
+   * Optional because a swap-to-address (private send) destination has no payout
+   * wallet; `payoutAddress` carries the destination in that case. GUI
+   * `savedAction` consumers that assume this is always present need a sweep
+   * before relying on it.
+   */
+  payoutWalletId?: string
+
   refundAddress?: string
 }
 
@@ -603,7 +612,14 @@ export interface EdgeTxSwap {
   payoutCurrencyCode: string
   payoutNativeAmount: string
   payoutTokenId?: EdgeTokenId
-  payoutWalletId: string
+
+  /**
+   * The wallet that received the payout, for a normal wallet-to-wallet swap.
+   * Optional because a swap-to-address (private send) destination has no
+   * payout wallet; `payoutAddress` carries the destination in that case.
+   */
+  payoutWalletId?: string
+
   refundAddress?: string
 }
 
@@ -1507,10 +1523,55 @@ export interface EdgeSwapInfo {
   readonly supportEmail: string
 }
 
+/**
+ * An address-only swap destination, used in place of a destination
+ * `toWallet` for "swap-to-address" (e.g. private send). The core builds a
+ * synthetic destination wallet from this descriptor, backed by the real
+ * `currencyConfig` for `toPluginId`, so swap plugins need no changes. The
+ * destination token is taken from the request's `toTokenId`, so it is not
+ * repeated here.
+ */
+export interface EdgeSwapToAddressInfo {
+  toPluginId: string
+  toAddress: string
+
+  /**
+   * Destination memos (e.g. an XRP destination tag) for memo-required payout
+   * chains. This descriptor field is only the GUI-to-core transport: swap
+   * plugins never read it. The core copies it onto the synthetic destination
+   * wallet, which exposes it through `getMemos` (see
+   * `EdgeSyntheticDestinationWallet`), so plugins consume destination memos
+   * through the wallet surface alone.
+   */
+  toMemos?: EdgeMemo[]
+}
+
+/**
+ * The extra surface a core-built synthetic destination wallet exposes on top
+ * of the `EdgeCurrencyWallet` members swap plugins normally read. Real
+ * wallets do not implement `getMemos`; plugins that support destination
+ * memos should detect it at runtime, such as:
+ * `const { getMemos } = toWallet as Partial<EdgeSyntheticDestinationWallet>`
+ */
+export interface EdgeSyntheticDestinationWallet extends EdgeCurrencyWallet {
+  readonly getMemos: () => Promise<EdgeMemo[]>
+}
+
 export interface EdgeSwapRequest {
   // Where?
   fromWallet: EdgeCurrencyWallet
-  toWallet: EdgeCurrencyWallet
+
+  /**
+   * The destination wallet for a normal wallet-to-wallet swap.
+   * Provide exactly one of `toWallet` or `toAddressInfo`.
+   */
+  toWallet?: EdgeCurrencyWallet
+
+  /**
+   * An address-only destination, as an alternative to `toWallet`.
+   * Provide exactly one of `toWallet` or `toAddressInfo`.
+   */
+  toAddressInfo?: EdgeSwapToAddressInfo
 
   // What?
   fromTokenId: EdgeTokenId