fix: aggregator limitations by chain (#99)

* added source swap fns for recipient per chain, aggregator limitations by chain

* fix: disable hyperevm in bebop

* fix: reenabled lifi & bebop for hyperevm

* fix: add optional receiverAddress to fix hyperevm issue & deliberate about taker and receiver

* feat: add object-arg wrappers with explicit takerAddress/receiverAddress to autochoice

Author: Makyl

src/xcs/autochoice.ts

@@ -24,6 +24,24 @@ import {
 import { Bytes } from "../types";
 import { Holding } from "./iface";
 
+// Legacy per-holding shape used by the deprecated `*ByRecipient` positional fns. `recipient`
+// historically doubled as both swap executor (taker) and output destination (receiver) — that
+// conflation is the root of GS013-class bugs. New code should pass `HoldingWithSwapAddresses`
+// to the new wrappers below; this type stays for backwards compat. The optional
+// `receiverAddress` lets the new wrappers thread per-holding receiver through legacy code.
+export type HoldingWithRecipient = Holding & {
+  recipient: Bytes;
+  receiverAddress?: Bytes;
+};
+
+// Per-holding shape for the new wrappers. Both `takerAddress` and `receiverAddress` are
+// required — even when source-side has them equal today, keeping both explicit forces every
+// call site to acknowledge each role.
+export type HoldingWithSwapAddresses = Holding & {
+  takerAddress: Bytes;
+  receiverAddress: Bytes;
+};
+
 export class AutoSelectionError extends Error {}
 const safetyMultiplier = new Decimal("1.025");
 
@@ -143,6 +161,10 @@ cots = [(1 COT, 1), (1 COT, 4)]
 5. return quotes and assets used.
 */
 
+/**
+ * @deprecated Use {@link autoSelectSources} (object args; per-holding `takerAddress` and
+ * `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
 export async function autoSelectSourcesV2(
   userAddress: Bytes,
   holdings: Holding[],
@@ -157,6 +179,32 @@ export async function autoSelectSourcesV2(
     idx: number;
     cur: Currency;
   }[];
+}> {
+  return autoSelectSourcesV2ByRecipient(
+    holdings.map((holding) => ({ ...holding, recipient: userAddress })),
+    outputRequired,
+    aggregators,
+    commonCurrencyID,
+  );
+}
+
+/**
+ * @deprecated Use {@link autoSelectSources} (object args; per-holding `takerAddress` and
+ * `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
+export async function autoSelectSourcesV2ByRecipient(
+  holdings: HoldingWithRecipient[],
+  outputRequired: Decimal,
+  aggregators: Aggregator[],
+  commonCurrencyID: CurrencyID = CurrencyID.USDC,
+): Promise<{
+  quoteResponses: QuoteResponse[];
+  usedCOTs: {
+    originalHolding: Holding;
+    amountUsed: Decimal;
+    idx: number;
+    cur: Currency;
+  }[];
 }> {
   // Assumption: Holding is already sorted in usage priority
   console.debug("XCS | SSV2:", {
@@ -217,7 +265,10 @@ export async function autoSelectSourcesV2(
     } else {
       fullLiquidationQuotes.push({
         req: {
-          userAddress,
+          userAddress: holding.recipient,
+          // New wrappers thread per-holding receiver via this field. Falls back to taker
+          // (`recipient`) when absent — preserves legacy positional-call behavior.
+          receiverAddress: holding.receiverAddress,
           type: QuoteType.EXACT_IN,
           chain: chain.ChainID,
           inputToken: holding.tokenAddress,
@@ -460,11 +511,16 @@ export async function autoSelectSourcesV2(
   return { quoteResponses: final, usedCOTs };
 }
 
+/**
+ * @deprecated Use {@link getDestinationExactOutSwap} (object args; explicit `takerAddress` and
+ * `receiverAddress`, both required).
+ */
 export async function determineDestinationSwaps(
   userAddress: Bytes,
   requirement: Holding,
   aggregators: Aggregator[],
   commonCurrencyID: CurrencyID = CurrencyID.USDC,
+  receiverAddress?: Bytes,
 ): Promise<QuoteResponse> {
   const chaindata = ChaindataMap.get(requirement.chainID);
   if (chaindata == null) {
@@ -483,6 +539,7 @@ export async function determineDestinationSwaps(
     type: QuoteType.EXACT_IN,
     chain: requirement.chainID,
     userAddress,
+    receiverAddress,
     inputToken: requirement.tokenAddress,
     outputToken: COT.tokenAddress,
     inputAmount: requirement.amountRaw,
@@ -518,6 +575,7 @@ export async function determineDestinationSwaps(
         {
           type: QuoteType.EXACT_IN,
           userAddress,
+          receiverAddress,
           chain: requirement.chainID,
           inputToken: COT.tokenAddress,
           outputToken: requirement.tokenAddress,
@@ -555,11 +613,34 @@ export async function determineDestinationSwaps(
   }
 }
 
+/**
+ * @deprecated Use {@link liquidateSourceHoldings} (object args; per-holding `takerAddress`
+ * and `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
 export async function liquidateInputHoldings(
   userAddress: Bytes,
   holdings: Holding[],
   aggregators: Aggregator[],
   commonCurrencyID = CurrencyID.USDC,
+  receiverAddress?: Bytes,
+): Promise<QuoteResponse[]> {
+  return liquidateInputHoldingsByRecipient(
+    holdings.map((holding) => ({ ...holding, recipient: userAddress })),
+    aggregators,
+    commonCurrencyID,
+    receiverAddress,
+  );
+}
+
+/**
+ * @deprecated Use {@link liquidateSourceHoldings} (object args; per-holding `takerAddress`
+ * and `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
+export async function liquidateInputHoldingsByRecipient(
+  holdings: HoldingWithRecipient[],
+  aggregators: Aggregator[],
+  commonCurrencyID = CurrencyID.USDC,
+  receiverAddress?: Bytes,
 ): Promise<QuoteResponse[]> {
   console.debug("XCS | LIH | Holdings:", holdings);
   const groupedByChainID = groupBy(holdings, (h) =>
@@ -607,7 +688,10 @@ export async function liquidateInputHoldings(
       }
       fullLiquidationQuotes.push({
         req: {
-          userAddress,
+          userAddress: holding.recipient,
+          // Per-holding receiver wins (set by the new wrappers); shared param is the legacy
+          // positional-call fallback.
+          receiverAddress: holding.receiverAddress ?? receiverAddress,
           type: QuoteType.EXACT_IN,
           chain: chain.ChainID,
           inputToken: holding.tokenAddress,
@@ -645,13 +729,18 @@ export async function liquidateInputHoldings(
   return quotes;
 }
 
+/**
+ * @deprecated Use {@link getDestinationExactInSwap} (object args; explicit `takerAddress`
+ * and `receiverAddress`, both required).
+ */
 export async function destinationSwapWithExactIn(
   userAddress: Bytes,
   omniChainID: OmniversalChainID,
   inputAmount: bigint,
   outputToken: Bytes,
   aggregators: Aggregator[],
   inputCurrency: CurrencyID = CurrencyID.USDC,
+  receiverAddress?: Bytes,
 ): Promise<QuoteResponse> {
   const chaindata = ChaindataMap.get(omniChainID);
   if (chaindata == null) {
@@ -669,6 +758,7 @@ export async function destinationSwapWithExactIn(
         type: QuoteType.EXACT_IN,
         chain: omniChainID,
         userAddress,
+        receiverAddress,
         inputToken: COT.tokenAddress,
         outputToken: outputToken,
         inputAmount: inputAmount,
@@ -700,3 +790,99 @@ export async function destinationSwapWithExactIn(
     },
   };
 }
+
+// =====================================================================================
+// Object-arg wrappers around the legacy positional functions above.
+//
+// Aggregator vocabulary:
+//   takerAddress    — on-chain executor of the swap (drives aggregator simulation /
+//                     permit / approval routing). On 7702 chains this is the ephemeral; on
+//                     non-Pectra chains it's the deployed Safe. Maps to the underlying
+//                     QuoteRequest's `userAddress`.
+//   receiverAddress — recipient of the swap output. Maps to the underlying QuoteRequest's
+//                     `receiverAddress`. Required on all 4 wrappers — the GS013-class bug we
+//                     fixed came from forgetting this and silently defaulting to the wrong
+//                     address. Even on source side (where it equals the taker today), require
+//                     it explicitly so the type system forces every call site to acknowledge
+//                     both roles.
+//
+// Wrap-only: each wrapper delegates to the deprecated positional fn. No business logic added.
+// =====================================================================================
+
+export async function getDestinationExactOutSwap(args: {
+  takerAddress: Bytes;
+  receiverAddress: Bytes;
+  requirement: Holding;
+  aggregators: Aggregator[];
+  commonCurrencyID?: CurrencyID;
+}): Promise<QuoteResponse> {
+  return determineDestinationSwaps(
+    args.takerAddress,
+    args.requirement,
+    args.aggregators,
+    args.commonCurrencyID,
+    args.receiverAddress,
+  );
+}
+
+export async function getDestinationExactInSwap(args: {
+  takerAddress: Bytes;
+  receiverAddress: Bytes;
+  chain: OmniversalChainID;
+  inputAmount: bigint;
+  outputToken: Bytes;
+  aggregators: Aggregator[];
+  inputCurrency?: CurrencyID;
+}): Promise<QuoteResponse> {
+  return destinationSwapWithExactIn(
+    args.takerAddress,
+    args.chain,
+    args.inputAmount,
+    args.outputToken,
+    args.aggregators,
+    args.inputCurrency,
+    args.receiverAddress,
+  );
+}
+
+export async function liquidateSourceHoldings(args: {
+  holdings: HoldingWithSwapAddresses[];
+  aggregators: Aggregator[];
+  commonCurrencyID?: CurrencyID;
+}): Promise<QuoteResponse[]> {
+  return liquidateInputHoldingsByRecipient(
+    args.holdings.map((h) => ({
+      ...h,
+      recipient: h.takerAddress,
+      receiverAddress: h.receiverAddress,
+    })),
+    args.aggregators,
+    args.commonCurrencyID,
+  );
+}
+
+export async function autoSelectSources(args: {
+  holdings: HoldingWithSwapAddresses[];
+  outputRequired: Decimal;
+  aggregators: Aggregator[];
+  commonCurrencyID?: CurrencyID;
+}): Promise<{
+  quoteResponses: QuoteResponse[];
+  usedCOTs: {
+    originalHolding: Holding;
+    amountUsed: Decimal;
+    idx: number;
+    cur: Currency;
+  }[];
+}> {
+  return autoSelectSourcesV2ByRecipient(
+    args.holdings.map((h) => ({
+      ...h,
+      recipient: h.takerAddress,
+      receiverAddress: h.receiverAddress,
+    })),
+    args.outputRequired,
+    args.aggregators,
+    args.commonCurrencyID,
+  );
+}

src/xcs/bebop-agg.ts

@@ -19,17 +19,11 @@ const ChainNameMapping = new Map(
     arbitrum: 42161,
     optimism: 10,
     base: 8453,
-    taiko: 167000,
     bsc: 56,
-    monadtestnet: 10143,
-    megaethtestnet: 6342,
-    berachain: 80094,
+    avalanche: 43114,
     polygon: 137,
-    zksync: 324,
-    blast: 81457,
-    mode: 34443,
     scroll: 534352,
-    superseed: 5330,
+    hyperevm: 999,
   }).map(([k, v]) => [bytesToHex(encodeChainID36(Universe.ETHEREUM, v)), k]),
 );
 // const erc7528Addr = Buffer.from('000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', 'hex')
@@ -190,6 +184,10 @@ export class BebopAggregator implements Aggregator {
           const userAddrHex = getAddress(
             bytesToHex(r.userAddress.subarray(12)),
           );
+          const receiverAddrHex =
+            r.receiverAddress != null
+              ? getAddress(bytesToHex(r.receiverAddress.subarray(12)))
+              : userAddrHex;
 
           switch (r.type) {
             case QuoteType.EXACT_IN: {
@@ -200,6 +198,7 @@ export class BebopAggregator implements Aggregator {
                   sell_tokens: inputTokenAddr,
                   buy_tokens: outputTokenAddr,
                   taker_address: userAddrHex,
+                  receiver_address: receiverAddrHex,
                   sell_amounts: r.inputAmount.toString(),
                   ...BebopAggregator.COMMON_OPTIONS,
                 },
@@ -214,6 +213,7 @@ export class BebopAggregator implements Aggregator {
                   sell_tokens: inputTokenAddr,
                   buy_tokens: outputTokenAddr,
                   taker_address: userAddrHex,
+                  receiver_address: receiverAddrHex,
                   buy_amounts: r.outputAmount.toString(),
                   ...BebopAggregator.COMMON_OPTIONS,
                 },
@@ -248,7 +248,7 @@ export class BebopAggregator implements Aggregator {
           const outputAmountInDecimal = new Decimal(buyT.minimumAmount)
             .div(Decimal.pow(10, buyT.decimals))
             .toFixed(buyT.decimals);
-            
+
           const inputAmountInDecimal = new Decimal(sellT.amount)
             .div(Decimal.pow(10, sellT.decimals))
             .toFixed(sellT.decimals);

src/xcs/fibrous-agg.ts

@@ -21,7 +21,7 @@ import {
 } from "./iface";
 
 const ChainNameMapping = new ChainIDKeyedMap<string>([
-  [new OmniversalChainID(Universe.ETHEREUM, 8453), "base"],
+  // [new OmniversalChainID(Universe.ETHEREUM, 8453), "base"], // Disabled because of few liquidity issues
   [new OmniversalChainID(Universe.ETHEREUM, 999), "hyperevm"],
   [new OmniversalChainID(Universe.ETHEREUM, 143), "monad"],
   [new OmniversalChainID(Universe.ETHEREUM, 4114), "citrea"],
@@ -123,6 +123,10 @@ export class FibrousAggregator implements Aggregator {
           const userAddrHex = getAddress(
             bytesToHex(r.userAddress.subarray(12)),
           );
+          const receiverAddrHex =
+            r.receiverAddress != null
+              ? getAddress(bytesToHex(r.receiverAddress.subarray(12)))
+              : userAddrHex;
 
           let resp: AxiosResponse<FibrousResponse>;
           try {
@@ -134,7 +138,7 @@ export class FibrousAggregator implements Aggregator {
                 tokenInAddress: inputTokenAddr,
                 tokenOutAddress: outputTokenAddr,
                 slippage: this.slippage,
-                destination: userAddrHex,
+                destination: receiverAddrHex,
               },
             });
           } catch (e) {
@@ -246,7 +250,10 @@ export class FibrousAggregator implements Aggregator {
           return item.value;
         }
         case "rejected": {
-          console.error("Caught error in fetching Fibrous quotes:", item.reason);
+          console.error(
+            "Caught error in fetching Fibrous quotes:",
+            item.reason,
+          );
           return null;
         }
       }

src/xcs/iface.ts

@@ -56,6 +56,11 @@ export interface Quote {
 
 type CommonQuoteParameters = {
   userAddress: Bytes;
+  // Optional output recipient. When omitted, defaults to userAddress (output returns to
+  // the caller — current behavior). When set, the aggregator delivers the swap output to
+  // this address instead. Used by destination-leg swaps that want output to go straight
+  // to the user's EOA rather than the wrapper account that signs the swap.
+  receiverAddress?: Bytes;
   chain: OmniversalChainID;
   inputToken: Bytes;
   outputToken: Bytes;