@avail-project/ca-common 2.0.0 → 2.2.0

package/dist/esm/xcs/autochoice.js

@@ -98,7 +98,18 @@ cots = [(1 COT, 1), (1 COT, 4)]
     break
 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, holdings, outputRequired, aggregators, commonCurrencyID = CurrencyID.USDC) {
+    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, outputRequired, aggregators, commonCurrencyID = CurrencyID.USDC) {
     // Assumption: Holding is already sorted in usage priority
     console.debug("XCS | SSV2:", {
         holdings,
@@ -132,7 +143,10 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
         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,
@@ -316,7 +330,11 @@ export async function autoSelectSourcesV2(userAddress, holdings, outputRequired,
     console.log("final_quotes", { quotes: final, cots: usedCOTs });
     return { quoteResponses: final, usedCOTs };
 }
-export async function determineDestinationSwaps(userAddress, requirement, aggregators, commonCurrencyID = CurrencyID.USDC) {
+/**
+ * @deprecated Use {@link getDestinationExactOutSwap} (object args; explicit `takerAddress` and
+ * `receiverAddress`, both required).
+ */
+export async function determineDestinationSwaps(userAddress, requirement, aggregators, commonCurrencyID = CurrencyID.USDC, receiverAddress) {
     const chaindata = ChaindataMap.get(requirement.chainID);
     if (chaindata == null) {
         throw new AutoSelectionError("Chain not found");
@@ -331,6 +349,7 @@ export async function determineDestinationSwaps(userAddress, requirement, aggreg
         type: QuoteType.EXACT_IN,
         chain: requirement.chainID,
         userAddress,
+        receiverAddress,
         inputToken: requirement.tokenAddress,
         outputToken: COT.tokenAddress,
         inputAmount: requirement.amountRaw,
@@ -354,6 +373,7 @@ export async function determineDestinationSwaps(userAddress, requirement, aggreg
             {
                 type: QuoteType.EXACT_IN,
                 userAddress,
+                receiverAddress,
                 chain: requirement.chainID,
                 inputToken: COT.tokenAddress,
                 outputToken: requirement.tokenAddress,
@@ -385,7 +405,18 @@ export async function determineDestinationSwaps(userAddress, requirement, aggreg
         }
     }
 }
-export async function liquidateInputHoldings(userAddress, holdings, aggregators, commonCurrencyID = CurrencyID.USDC) {
+/**
+ * @deprecated Use {@link liquidateSourceHoldings} (object args; per-holding `takerAddress`
+ * and `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
+export async function liquidateInputHoldings(userAddress, holdings, aggregators, commonCurrencyID = CurrencyID.USDC, receiverAddress) {
+    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, aggregators, commonCurrencyID = CurrencyID.USDC, receiverAddress) {
     console.debug("XCS | LIH | Holdings:", holdings);
     const groupedByChainID = groupBy(holdings, (h) => bytesToHex(h.chainID.toBytes()));
     const fullLiquidationQuotes = [];
@@ -409,7 +440,10 @@ export async function liquidateInputHoldings(userAddress, holdings, aggregators,
             }
             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,
@@ -438,7 +472,11 @@ export async function liquidateInputHoldings(userAddress, holdings, aggregators,
     }
     return quotes;
 }
-export async function destinationSwapWithExactIn(userAddress, omniChainID, inputAmount, outputToken, aggregators, inputCurrency = CurrencyID.USDC) {
+/**
+ * @deprecated Use {@link getDestinationExactInSwap} (object args; explicit `takerAddress`
+ * and `receiverAddress`, both required).
+ */
+export async function destinationSwapWithExactIn(userAddress, omniChainID, inputAmount, outputToken, aggregators, inputCurrency = CurrencyID.USDC, receiverAddress) {
     const chaindata = ChaindataMap.get(omniChainID);
     if (chaindata == null) {
         throw new AutoSelectionError("Chain not found");
@@ -452,6 +490,7 @@ export async function destinationSwapWithExactIn(userAddress, omniChainID, input
             type: QuoteType.EXACT_IN,
             chain: omniChainID,
             userAddress,
+            receiverAddress,
             inputToken: COT.tokenAddress,
             outputToken: outputToken,
             inputAmount: inputAmount,
@@ -476,3 +515,40 @@ export async function destinationSwapWithExactIn(userAddress, omniChainID, input
         },
     };
 }
+// =====================================================================================
+// 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) {
+    return determineDestinationSwaps(args.takerAddress, args.requirement, args.aggregators, args.commonCurrencyID, args.receiverAddress);
+}
+export async function getDestinationExactInSwap(args) {
+    return destinationSwapWithExactIn(args.takerAddress, args.chain, args.inputAmount, args.outputToken, args.aggregators, args.inputCurrency, args.receiverAddress);
+}
+export async function liquidateSourceHoldings(args) {
+    return liquidateInputHoldingsByRecipient(args.holdings.map((h) => ({
+        ...h,
+        recipient: h.takerAddress,
+        receiverAddress: h.receiverAddress,
+    })), args.aggregators, args.commonCurrencyID);
+}
+export async function autoSelectSources(args) {
+    return autoSelectSourcesV2ByRecipient(args.holdings.map((h) => ({
+        ...h,
+        recipient: h.takerAddress,
+        receiverAddress: h.receiverAddress,
+    })), args.outputRequired, args.aggregators, args.commonCurrencyID);
+}

package/dist/esm/xcs/bebop-agg.js

@@ -10,17 +10,11 @@ const ChainNameMapping = new Map(Object.entries({
     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]));
 export class BebopAggregator {
     static BASE_URL = "https://api.bebop.xyz/router";
@@ -52,6 +46,9 @@ export class BebopAggregator {
             const inputTokenAddr = getAddress(bytesToHex(r.inputToken.subarray(12)));
             const outputTokenAddr = getAddress(bytesToHex(r.outputToken.subarray(12)));
             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: {
                     respPromise = this.axios({
@@ -61,6 +58,7 @@ export class BebopAggregator {
                             sell_tokens: inputTokenAddr,
                             buy_tokens: outputTokenAddr,
                             taker_address: userAddrHex,
+                            receiver_address: receiverAddrHex,
                             sell_amounts: r.inputAmount.toString(),
                             ...BebopAggregator.COMMON_OPTIONS,
                         },
@@ -75,6 +73,7 @@ export class BebopAggregator {
                             sell_tokens: inputTokenAddr,
                             buy_tokens: outputTokenAddr,
                             taker_address: userAddrHex,
+                            receiver_address: receiverAddrHex,
                             buy_amounts: r.outputAmount.toString(),
                             ...BebopAggregator.COMMON_OPTIONS,
                         },

package/dist/esm/xcs/fibrous-agg.js

@@ -0,0 +1,147 @@
+import axios, { AxiosError } from "axios";
+import Decimal from "decimal.js";
+import { bytesToHex, encodeFunctionData, getAddress, toHex, zeroAddress, } from "viem";
+import { ChainIDKeyedMap, OmniversalChainID } from "../data";
+import { FibrousRouterABI } from "../evmabi";
+import { Universe } from "../proto/definition";
+import { QuoteType, } from "./iface";
+const ChainNameMapping = new ChainIDKeyedMap([
+    // [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"],
+]);
+export class FibrousAggregator {
+    static BASE_URL = "https://api.fibrous.finance";
+    axios;
+    slippage;
+    constructor(options = {}) {
+        const { apiKey, slippage = 0.5 } = options;
+        this.slippage = slippage;
+        this.axios = axios.create({
+            baseURL: FibrousAggregator.BASE_URL,
+            headers: apiKey != null ? { "X-API-Key": apiKey } : undefined,
+            timeout: 10_000,
+        });
+    }
+    async getQuotes(requests) {
+        const list = await Promise.allSettled(requests.map(async (r) => {
+            if (r.type === QuoteType.EXACT_OUT) {
+                return null;
+            }
+            if (r.chain.universe !== Universe.ETHEREUM) {
+                return null;
+            }
+            const chainName = ChainNameMapping.get(r.chain);
+            if (chainName == null) {
+                return null;
+            }
+            const inputTokenAddr = getAddress(bytesToHex(r.inputToken.subarray(12)));
+            const outputTokenAddr = getAddress(bytesToHex(r.outputToken.subarray(12)));
+            const userAddrHex = getAddress(bytesToHex(r.userAddress.subarray(12)));
+            const receiverAddrHex = r.receiverAddress != null
+                ? getAddress(bytesToHex(r.receiverAddress.subarray(12)))
+                : userAddrHex;
+            let resp;
+            try {
+                resp = await this.axios({
+                    method: "GET",
+                    url: `/${chainName}/v2/routeAndCallData`,
+                    params: {
+                        amount: r.inputAmount.toString(),
+                        tokenInAddress: inputTokenAddr,
+                        tokenOutAddress: outputTokenAddr,
+                        slippage: this.slippage,
+                        destination: receiverAddrHex,
+                    },
+                });
+            }
+            catch (e) {
+                if (e instanceof AxiosError && e.isAxiosError) {
+                    return null;
+                }
+                throw e;
+            }
+            if (!resp.data.route.success) {
+                return null;
+            }
+            if (resp.data.calldata.swap_parameters.length === 0) {
+                return null;
+            }
+            const inputAmountInDecimal = new Decimal(resp.data.route.inputAmount)
+                .div(Decimal.pow(10, resp.data.route.inputToken.decimals))
+                .toFixed(resp.data.route.inputToken.decimals);
+            const outputAmountInDecimal = new Decimal(resp.data.calldata.route.min_received)
+                .div(Decimal.pow(10, resp.data.route.outputToken.decimals))
+                .toFixed(resp.data.route.outputToken.decimals);
+            const routerAddress = getAddress(resp.data.router_address);
+            const isNativeInput = resp.data.calldata.route.swap_type === 0;
+            const quote = {
+                originalResponse: resp.data,
+                input: {
+                    amount: inputAmountInDecimal,
+                    amountRaw: BigInt(resp.data.route.inputAmount),
+                    contractAddress: inputTokenAddr,
+                    decimals: resp.data.route.inputToken.decimals,
+                    value: Decimal.mul(inputAmountInDecimal, resp.data.route.inputToken.price ?? 0).toNumber(),
+                    symbol: resp.data.route.inputToken.symbol ??
+                        resp.data.route.inputToken.name,
+                },
+                output: {
+                    amount: outputAmountInDecimal,
+                    amountRaw: BigInt(resp.data.calldata.route.min_received),
+                    contractAddress: outputTokenAddr,
+                    decimals: resp.data.route.outputToken.decimals,
+                    value: Decimal.mul(outputAmountInDecimal, resp.data.route.outputToken.price ?? 0).toNumber(),
+                    symbol: resp.data.route.outputToken.symbol ??
+                        resp.data.route.outputToken.name,
+                },
+                txData: {
+                    approvalAddress: isNativeInput ? zeroAddress : routerAddress,
+                    tx: {
+                        to: routerAddress,
+                        value: isNativeInput
+                            ? toHex(BigInt(resp.data.calldata.route.amount_in))
+                            : toHex(0),
+                        data: encodeFunctionData({
+                            abi: FibrousRouterABI,
+                            functionName: "swap",
+                            args: [
+                                {
+                                    token_in: getAddress(resp.data.calldata.route.token_in),
+                                    token_out: getAddress(resp.data.calldata.route.token_out),
+                                    amount_in: BigInt(resp.data.calldata.route.amount_in),
+                                    amount_out: BigInt(resp.data.calldata.route.amount_out),
+                                    min_received: BigInt(resp.data.calldata.route.min_received),
+                                    destination: getAddress(resp.data.calldata.route.destination),
+                                    swap_type: resp.data.calldata.route.swap_type,
+                                },
+                                resp.data.calldata.swap_parameters.map((swapParameter) => ({
+                                    token_in: getAddress(swapParameter.token_in),
+                                    token_out: getAddress(swapParameter.token_out),
+                                    rate: Number.parseInt(swapParameter.rate, 10),
+                                    protocol_id: Number.parseInt(swapParameter.protocol_id, 10),
+                                    pool_address: getAddress(swapParameter.pool_address),
+                                    swap_type: swapParameter.swap_type,
+                                    extra_data: swapParameter.extra_data,
+                                })),
+                            ],
+                        }),
+                    },
+                },
+            };
+            return quote;
+        }));
+        return list.map((item) => {
+            switch (item.status) {
+                case "fulfilled": {
+                    return item.value;
+                }
+                case "rejected": {
+                    console.error("Caught error in fetching Fibrous quotes:", item.reason);
+                    return null;
+                }
+            }
+        });
+    }
+}

package/dist/esm/xcs/index.js

@@ -1,4 +1,5 @@
 export * from './iface';
 export * from './lifi-agg';
 export * from './bebop-agg';
+export * from './fibrous-agg';
 export * from './autochoice';

package/dist/esm/xcs/lifi-agg.js

@@ -3,6 +3,20 @@ import { bytesToHex, getAddress } from "viem";
 import { QuoteType, } from "./iface";
 import { Universe } from "../proto/definition";
 import Decimal from "decimal.js";
+const ALLOWED_CHAINS = new Set([
+    1, // Ethereum
+    10, // Optimism
+    56, // BSC
+    137, // Polygon
+    143, // Monad
+    999, // HyperEVM
+    4326, // MegaETH
+    8453, // Base
+    42161, // Arbitrum
+    43114, // Avalanche
+    8217, // Kaia
+    534352, // Scroll
+]);
 export class LiFiAggregator {
     static BASE_URL_V1 = "https://li.quest/v1";
     static COMMON_OPTIONS = {
@@ -25,11 +39,17 @@ export class LiFiAggregator {
             if (r.chain.universe !== Universe.ETHEREUM) {
                 return null;
             }
+            if (!ALLOWED_CHAINS.has(Number(r.chain.chainID))) {
+                return null;
+            }
             let respPromise;
             const chIDStr = r.chain.chainID.toString();
             const inputTokenAddr = getAddress(bytesToHex(r.inputToken.subarray(12)));
             const outputTokenAddr = getAddress(bytesToHex(r.outputToken.subarray(12)));
             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: {
                     respPromise = this.axios({
@@ -41,6 +61,7 @@ export class LiFiAggregator {
                             fromToken: inputTokenAddr,
                             toToken: outputTokenAddr,
                             fromAddress: userAddrHex,
+                            toAddress: receiverAddrHex,
                             fromAmount: r.inputAmount.toString(),
                             ...LiFiAggregator.COMMON_OPTIONS,
                         },
@@ -57,6 +78,7 @@ export class LiFiAggregator {
                             fromToken: inputTokenAddr,
                             toToken: outputTokenAddr,
                             fromAddress: userAddrHex,
+                            toAddress: receiverAddrHex,
                             toAmount: r.outputAmount.toString(),
                             ...LiFiAggregator.COMMON_OPTIONS,
                         },

package/dist/types/evmabi/fibrousrouter.abi.d.ts

@@ -0,0 +1,77 @@
+export declare const FibrousRouterABI: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "token_in";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "token_out";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount_in";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount_out";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "min_received";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "destination";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "swap_type";
+            readonly type: "uint8";
+        }];
+        readonly internalType: "struct IFibrousRouter.RouteParam";
+        readonly name: "route";
+        readonly type: "tuple";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "token_in";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "token_out";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint32";
+            readonly name: "rate";
+            readonly type: "uint32";
+        }, {
+            readonly internalType: "int24";
+            readonly name: "protocol_id";
+            readonly type: "int24";
+        }, {
+            readonly internalType: "address";
+            readonly name: "pool_address";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint8";
+            readonly name: "swap_type";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "extra_data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct IFibrousRouter.SwapParams[]";
+        readonly name: "swap_parameters";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "swap";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];

package/dist/types/evmabi/index.d.ts

@@ -1,3 +1,4 @@
 export * from './erc20.abi';
 export * from './vault.abi';
 export * from './yakaggregator.abi';
+export * from './fibrousrouter.abi';

package/dist/types/proto/definition.d.ts

@@ -227,12 +227,18 @@ export interface AdminFeeRecipient {
     universe: Universe;
     address: Uint8Array;
 }
+export interface PerChainFeeBP {
+    universe: Universe;
+    chainID: Uint8Array;
+    feeBP: Long;
+}
 export interface ProtocolFees {
     feeBP: Long;
     collectionFees: FixedFeeTuple[];
     fulfilmentFees: FixedFeeTuple[];
     admin: string;
     feeRecipients: AdminFeeRecipient[];
+    perChainFeeBP: PerChainFeeBP[];
 }
 export interface QueryGetProtocolFeesRequest {
 }
@@ -245,6 +251,7 @@ export interface MsgCreateProtocolFees {
     collectionFees: FixedFeeTuple[];
     fulfilmentFees: FixedFeeTuple[];
     feeRecipients: AdminFeeRecipient[];
+    perChainFeeBP: PerChainFeeBP[];
 }
 export interface MsgCreateProtocolFeesResponse {
 }
@@ -254,6 +261,7 @@ export interface MsgUpdateProtocolFees {
     collectionFees: FixedFeeTuple[];
     fulfilmentFees: FixedFeeTuple[];
     feeRecipients: AdminFeeRecipient[];
+    perChainFeeBP: PerChainFeeBP[];
 }
 export interface MsgUpdateProtocolFeesResponse {
 }
@@ -330,6 +338,7 @@ export declare const QueryAllSettlementResponse: MessageFns<QueryAllSettlementRe
 export declare const QueryRequestForFundsByAddressRequest: MessageFns<QueryRequestForFundsByAddressRequest>;
 export declare const FixedFeeTuple: MessageFns<FixedFeeTuple>;
 export declare const AdminFeeRecipient: MessageFns<AdminFeeRecipient>;
+export declare const PerChainFeeBP: MessageFns<PerChainFeeBP>;
 export declare const ProtocolFees: MessageFns<ProtocolFees>;
 export declare const QueryGetProtocolFeesRequest: MessageFns<QueryGetProtocolFeesRequest>;
 export declare const QueryGetProtocolFeesResponse: MessageFns<QueryGetProtocolFeesResponse>;

package/dist/types/xcs/autochoice.d.ts

@@ -3,6 +3,14 @@ import { Aggregator, Quote, QuoteRequestExactInput, QuoteRequestExactOutput, Quo
 import { Currency, CurrencyID, OmniversalChainID } from "../data";
 import { Bytes } from "../types";
 import { Holding } from "./iface";
+export type HoldingWithRecipient = Holding & {
+    recipient: Bytes;
+    receiverAddress?: Bytes;
+};
+export type HoldingWithSwapAddresses = Holding & {
+    takerAddress: Bytes;
+    receiverAddress: Bytes;
+};
 export declare class AutoSelectionError extends Error {
 }
 declare const enum AggregateAggregatorsMode {
@@ -13,6 +21,10 @@ export declare function aggregateAggregators(requests: (QuoteRequestExactInput |
     quote: Quote | null;
     aggregator: Aggregator;
 }[]>;
+/**
+ * @deprecated Use {@link autoSelectSources} (object args; per-holding `takerAddress` and
+ * `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
 export declare function autoSelectSourcesV2(userAddress: Bytes, holdings: Holding[], outputRequired: Decimal, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<{
     quoteResponses: QuoteResponse[];
     usedCOTs: {
@@ -22,7 +34,72 @@ export declare function autoSelectSourcesV2(userAddress: Bytes, holdings: Holdin
         cur: Currency;
     }[];
 }>;
-export declare function determineDestinationSwaps(userAddress: Bytes, requirement: Holding, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<QuoteResponse>;
-export declare function liquidateInputHoldings(userAddress: Bytes, holdings: Holding[], aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<QuoteResponse[]>;
-export declare function destinationSwapWithExactIn(userAddress: Bytes, omniChainID: OmniversalChainID, inputAmount: bigint, outputToken: Bytes, aggregators: Aggregator[], inputCurrency?: CurrencyID): Promise<QuoteResponse>;
+/**
+ * @deprecated Use {@link autoSelectSources} (object args; per-holding `takerAddress` and
+ * `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
+export declare function autoSelectSourcesV2ByRecipient(holdings: HoldingWithRecipient[], outputRequired: Decimal, aggregators: Aggregator[], commonCurrencyID?: CurrencyID): Promise<{
+    quoteResponses: QuoteResponse[];
+    usedCOTs: {
+        originalHolding: Holding;
+        amountUsed: Decimal;
+        idx: number;
+        cur: Currency;
+    }[];
+}>;
+/**
+ * @deprecated Use {@link getDestinationExactOutSwap} (object args; explicit `takerAddress` and
+ * `receiverAddress`, both required).
+ */
+export declare function determineDestinationSwaps(userAddress: Bytes, requirement: Holding, aggregators: Aggregator[], commonCurrencyID?: CurrencyID, receiverAddress?: Bytes): Promise<QuoteResponse>;
+/**
+ * @deprecated Use {@link liquidateSourceHoldings} (object args; per-holding `takerAddress`
+ * and `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
+export declare function liquidateInputHoldings(userAddress: Bytes, holdings: Holding[], aggregators: Aggregator[], commonCurrencyID?: CurrencyID, receiverAddress?: Bytes): Promise<QuoteResponse[]>;
+/**
+ * @deprecated Use {@link liquidateSourceHoldings} (object args; per-holding `takerAddress`
+ * and `receiverAddress` on each `HoldingWithSwapAddresses`).
+ */
+export declare function liquidateInputHoldingsByRecipient(holdings: HoldingWithRecipient[], aggregators: Aggregator[], commonCurrencyID?: CurrencyID, receiverAddress?: Bytes): Promise<QuoteResponse[]>;
+/**
+ * @deprecated Use {@link getDestinationExactInSwap} (object args; explicit `takerAddress`
+ * and `receiverAddress`, both required).
+ */
+export declare function destinationSwapWithExactIn(userAddress: Bytes, omniChainID: OmniversalChainID, inputAmount: bigint, outputToken: Bytes, aggregators: Aggregator[], inputCurrency?: CurrencyID, receiverAddress?: Bytes): Promise<QuoteResponse>;
+export declare function getDestinationExactOutSwap(args: {
+    takerAddress: Bytes;
+    receiverAddress: Bytes;
+    requirement: Holding;
+    aggregators: Aggregator[];
+    commonCurrencyID?: CurrencyID;
+}): Promise<QuoteResponse>;
+export declare function getDestinationExactInSwap(args: {
+    takerAddress: Bytes;
+    receiverAddress: Bytes;
+    chain: OmniversalChainID;
+    inputAmount: bigint;
+    outputToken: Bytes;
+    aggregators: Aggregator[];
+    inputCurrency?: CurrencyID;
+}): Promise<QuoteResponse>;
+export declare function liquidateSourceHoldings(args: {
+    holdings: HoldingWithSwapAddresses[];
+    aggregators: Aggregator[];
+    commonCurrencyID?: CurrencyID;
+}): Promise<QuoteResponse[]>;
+export declare function autoSelectSources(args: {
+    holdings: HoldingWithSwapAddresses[];
+    outputRequired: Decimal;
+    aggregators: Aggregator[];
+    commonCurrencyID?: CurrencyID;
+}): Promise<{
+    quoteResponses: QuoteResponse[];
+    usedCOTs: {
+        originalHolding: Holding;
+        amountUsed: Decimal;
+        idx: number;
+        cur: Currency;
+    }[];
+}>;
 export {};